+Fri May 12 17:13:32 2000 Tim Janik <timj@gtk.org>
+
+ * docs/Changes-1.4.txt: documented necessary changes for 1.4 transition.
+
+ * gtk/gtktext.c: made the adjustments no-construct args, simply
+ provide default adjustments.
+ (gtk_text_destroy): release adjustments.
+
+ * gtk/gtkprogressbar.c (gtk_progress_bar_class_init): made the
+ adjustment argument non-construct.
+
+ * gtk/gtkprogress.c (gtk_progress_destroy): release adjustment here,
+ instead of in finalize.
+ (gtk_progress_get_text_from_value):
+ (gtk_progress_get_current_text):
+ (gtk_progress_set_value):
+ (gtk_progress_get_percentage_from_value):
+ (gtk_progress_get_current_percentage):
+ (gtk_progress_set_percentage):
+ (gtk_progress_configure): ensure an adjustment is present.
+
+Thu May 11 01:24:08 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcolorsel.[hc]:
+ * gtk/gtkcolorseldialog.[hc]:
+ * gtk/gtkhsv.[hc]: major code cleanups, destroy handlers need to chain
+ their parent implementation, use bit fields for boolean values, don't
+ create unused widgets, usage of glib types, braces go on their own
+ lines, function argument alignment, #include directives etc. etc. etc..
+
+ * gtk/Makefile.am (gtk_public_h_sources): install gtkhsv.h.
+
+Wed May 10 23:29:52 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtktoolbar.c (gtk_toolbar_destroy): don't unref a NULL tooltips.
+
+ * gtk/gtkfilesel.c (gtk_file_selection_destroy): don't free a cmpl_state
+ of NULL.
+
+ * gtk/gtkcombo.c (gtk_combo_item_destroy): don#t keep references
+ to freed data.
+ (gtk_combo_destroy): don't keep a pointer to a destroyed window.
+
+ * gtk/gtkmenu.c (gtk_menu_init): reset the menu's toplevel pointer
+ to NULL when the toplevel is getting destroyed.
+ (gtk_menu_set_tearoff_state): same here for the tearoff_window.
+ (gtk_menu_destroy):
+ (gtk_menu_init): store the information of whether we have to
+ readd the initial child ref_count during destruction in a new
+ GtkMenu field needs_destruction_ref_count.
+
+ * gtk/gtkviewport.c: SHAME! ok this one is tricky, so i note it
+ here, those reading: learn from my mistake! ;)
+ in order for set_?adjustment to support a default adjustemnt if
+ invoked with an adjustment pointer of NULL, the code read (pseudo):
+ if (v->adjustment) unref (v->adjustment);
+ if (!adjustment) adjustment = adjustment_new ();
+ if (v->adjustment != adjustment) v->adjustment = ref (adjustment);
+ now imagine the first unref to actually free the old adjustment and
+ adjustment_new() creating a new adjustment from the very same memory
+ portion. here, the latter comparision will unintendedly fail, and
+ all hell breaks loose.
+ (gtk_viewport_set_hadjustment):
+ (gtk_viewport_set_vadjustment): reset viewport->?adjustment to NULL
+ after unreferencing it.
+
+ * gtk/gtkcontainer.[hc]: removed toplevel registration
+ functions: gtk_container_register_toplevel(),
+ gtk_container_unregister_toplevel() and
+ gtk_container_get_toplevels() which had wrong semantics
+ anyways: it didn't reference and copy the list.
+
+ * gtk/gtkwindow.c: we take over the container toplevel registration
+ bussiness now. windows are registered across multiple destructions,
+ untill they are finalized. the initial implicit reference count
+ users are holding on windows is removed with the first destruction
+ though.
+ (gtk_window_init): ref & sink and set has_user_ref_count, got
+ rid of gtk_container_register_toplevel() call. add window to
+ toplevel_list.
+ (gtk_window_destroy): unref the window if has_user_ref_count
+ is still set, got rid of call to
+ gtk_container_unregister_toplevel().
+ (gtk_window_finalize): remove window from toplevel list.
+ (gtk_window_list_toplevels): new function to return a newly
+ created list with referenced toplevels.
+ (gtk_window_read_rcfiles): use gtk_window_list_toplevels().
+
+ * gtk/gtkhscale.c (gtk_hscale_class_init): made the GtkRange
+ adjustment a non-construct arg.
+ * gtk/gtkvscale.c (gtk_vscale_class_init): likewise.
+ * gtk/gtkhscrollbar.c (gtk_vscrollbar_class_init): likewise.
+ * gtk/gtkvscrollbar.c (gtk_vscrollbar_class_init): likewise.
+
+ * gtk/gtkrange.c: added some realized checks.
+ (gtk_range_destroy): get rid of the h/v adjustments in the
+ destroy handler instead of finalize. remove timer.
+ (gtk_range_get_adjustment): demand create adjustment.
+
+ * gtk/gtkviewport.c: made h/v adjustment non-construct args.
+ we simply create them on demand now and get rid of them in
+ the destroy handler.
+ (gtk_viewport_destroy): get rid of the h/v adjustments in the
+ destroy handler instead of finalize.
+ (gtk_viewport_get_hadjustment):
+ (gtk_viewport_get_vadjustment):
+ (gtk_viewport_size_allocate): demand create h/v adjustment
+ if required.
+
+ * gtk/gtkwidget.c (gtk_widget_finalize): duplicate part of the
+ gtk_widget_real_destroy () functionality.
+ (gtk_widget_real_destroy): reinitialize with a new style, instead
+ of setting widget->style to NULL.
+
+Fri May 5 13:02:09 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcalendar.c:
+ * gtk/gtkbutton.c: ported _get_type() implementation over to
+ GType, either to preserve memchunks allocation facilities,
+ or because Gtk+ 1.0 GtkTypeInfo was still being used.
+
+ * gtk/gtkobject.[hc]: derive from GObject. ported various functions
+ over. prepare for ::destroy to be emitted multiple times.
+ removed reference tracer magic. chain into GObjectClass.shutdown()
+ to emit ::destroy signal.
+
+ * gtk/gtksignal.c: removed assumptions about GTK_TYPE_OBJECT being
+ fundamental.
+
+ * gtk/gtkmain.c: removed gtk_object_post_arg_parsing_init()
+ cludge.
+
+ * gtk/gtksocket.c:
+ * gtk/gtkplug.c:
+ * gtk/gtklayout.c:
+ * gtk/gtklabel.c:
+ * gtk/gtkargcollector.c:
+ * gtk/gtkarg.c: various fixups to work with GTK_TYPE_OBJECT
+ not being a fundamental anymore, and to work with the new
+ type system (nuked fundamental type varargs clutter).
+
+ * gtk/*.c: install finalize handlers in the GObjectClass
+ part of the class structure.
+ changed direct GTK_OBJECT()->klass accesses to
+ GTK_*_GET_CLASS().
+ changed direct object_class->type accesses to GTK_CLASS_TYPE().
+
+ * gtktypeutils.[hc]: use the reserved fundamental ids provided by
+ GType. made most of the GTK_*() type macros and Gtk* typedefs
+ simple wrappers around macros and types provided by GType.
+ most notably, a significant portion of the old API vanished:
+ GTK_TYPE_MAKE(),
+ GTK_TYPE_SEQNO(),
+ GTK_TYPE_FLAT_FIRST, GTK_TYPE_FLAT_LAST,
+ GTK_TYPE_STRUCTURED_FIRST, GTK_TYPE_STRUCTURED_LAST,
+ GTK_TYPE_ARGS,
+ GTK_TYPE_CALLBACK,
+ GTK_TYPE_C_CALLBACK,
+ GTK_TYPE_FOREIGN,
+ GtkTypeQuery,
+ gtk_type_query(),
+ gtk_type_set_varargs_type(),
+ gtk_type_get_varargs_type(),
+ gtk_type_check_object_cast(),
+ gtk_type_check_class_cast(),
+ gtk_type_describe_tree(),
+ gtk_type_describe_heritage(),
+ gtk_type_free(),
+ gtk_type_children_types(),
+ gtk_type_set_chunk_alloc(),
+ gtk_type_register_enum(),
+ gtk_type_register_flags(),
+ gtk_type_parent_class().
+ replacements, where available are described in ../docs/Changes-1.4.txt.
+ implemented compatibility functions for the remaining API.
+
+ * configure.in: depend on glib 1.3.1, use gobject module.
+
Thu May 11 12:39:50 2000 Owen Taylor <otaylor@redhat.com>
* TODO.xml: Various updates to current status.
+Fri May 12 17:13:32 2000 Tim Janik <timj@gtk.org>
+
+ * docs/Changes-1.4.txt: documented necessary changes for 1.4 transition.
+
+ * gtk/gtktext.c: made the adjustments no-construct args, simply
+ provide default adjustments.
+ (gtk_text_destroy): release adjustments.
+
+ * gtk/gtkprogressbar.c (gtk_progress_bar_class_init): made the
+ adjustment argument non-construct.
+
+ * gtk/gtkprogress.c (gtk_progress_destroy): release adjustment here,
+ instead of in finalize.
+ (gtk_progress_get_text_from_value):
+ (gtk_progress_get_current_text):
+ (gtk_progress_set_value):
+ (gtk_progress_get_percentage_from_value):
+ (gtk_progress_get_current_percentage):
+ (gtk_progress_set_percentage):
+ (gtk_progress_configure): ensure an adjustment is present.
+
+Thu May 11 01:24:08 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcolorsel.[hc]:
+ * gtk/gtkcolorseldialog.[hc]:
+ * gtk/gtkhsv.[hc]: major code cleanups, destroy handlers need to chain
+ their parent implementation, use bit fields for boolean values, don't
+ create unused widgets, usage of glib types, braces go on their own
+ lines, function argument alignment, #include directives etc. etc. etc..
+
+ * gtk/Makefile.am (gtk_public_h_sources): install gtkhsv.h.
+
+Wed May 10 23:29:52 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtktoolbar.c (gtk_toolbar_destroy): don't unref a NULL tooltips.
+
+ * gtk/gtkfilesel.c (gtk_file_selection_destroy): don't free a cmpl_state
+ of NULL.
+
+ * gtk/gtkcombo.c (gtk_combo_item_destroy): don#t keep references
+ to freed data.
+ (gtk_combo_destroy): don't keep a pointer to a destroyed window.
+
+ * gtk/gtkmenu.c (gtk_menu_init): reset the menu's toplevel pointer
+ to NULL when the toplevel is getting destroyed.
+ (gtk_menu_set_tearoff_state): same here for the tearoff_window.
+ (gtk_menu_destroy):
+ (gtk_menu_init): store the information of whether we have to
+ readd the initial child ref_count during destruction in a new
+ GtkMenu field needs_destruction_ref_count.
+
+ * gtk/gtkviewport.c: SHAME! ok this one is tricky, so i note it
+ here, those reading: learn from my mistake! ;)
+ in order for set_?adjustment to support a default adjustemnt if
+ invoked with an adjustment pointer of NULL, the code read (pseudo):
+ if (v->adjustment) unref (v->adjustment);
+ if (!adjustment) adjustment = adjustment_new ();
+ if (v->adjustment != adjustment) v->adjustment = ref (adjustment);
+ now imagine the first unref to actually free the old adjustment and
+ adjustment_new() creating a new adjustment from the very same memory
+ portion. here, the latter comparision will unintendedly fail, and
+ all hell breaks loose.
+ (gtk_viewport_set_hadjustment):
+ (gtk_viewport_set_vadjustment): reset viewport->?adjustment to NULL
+ after unreferencing it.
+
+ * gtk/gtkcontainer.[hc]: removed toplevel registration
+ functions: gtk_container_register_toplevel(),
+ gtk_container_unregister_toplevel() and
+ gtk_container_get_toplevels() which had wrong semantics
+ anyways: it didn't reference and copy the list.
+
+ * gtk/gtkwindow.c: we take over the container toplevel registration
+ bussiness now. windows are registered across multiple destructions,
+ untill they are finalized. the initial implicit reference count
+ users are holding on windows is removed with the first destruction
+ though.
+ (gtk_window_init): ref & sink and set has_user_ref_count, got
+ rid of gtk_container_register_toplevel() call. add window to
+ toplevel_list.
+ (gtk_window_destroy): unref the window if has_user_ref_count
+ is still set, got rid of call to
+ gtk_container_unregister_toplevel().
+ (gtk_window_finalize): remove window from toplevel list.
+ (gtk_window_list_toplevels): new function to return a newly
+ created list with referenced toplevels.
+ (gtk_window_read_rcfiles): use gtk_window_list_toplevels().
+
+ * gtk/gtkhscale.c (gtk_hscale_class_init): made the GtkRange
+ adjustment a non-construct arg.
+ * gtk/gtkvscale.c (gtk_vscale_class_init): likewise.
+ * gtk/gtkhscrollbar.c (gtk_vscrollbar_class_init): likewise.
+ * gtk/gtkvscrollbar.c (gtk_vscrollbar_class_init): likewise.
+
+ * gtk/gtkrange.c: added some realized checks.
+ (gtk_range_destroy): get rid of the h/v adjustments in the
+ destroy handler instead of finalize. remove timer.
+ (gtk_range_get_adjustment): demand create adjustment.
+
+ * gtk/gtkviewport.c: made h/v adjustment non-construct args.
+ we simply create them on demand now and get rid of them in
+ the destroy handler.
+ (gtk_viewport_destroy): get rid of the h/v adjustments in the
+ destroy handler instead of finalize.
+ (gtk_viewport_get_hadjustment):
+ (gtk_viewport_get_vadjustment):
+ (gtk_viewport_size_allocate): demand create h/v adjustment
+ if required.
+
+ * gtk/gtkwidget.c (gtk_widget_finalize): duplicate part of the
+ gtk_widget_real_destroy () functionality.
+ (gtk_widget_real_destroy): reinitialize with a new style, instead
+ of setting widget->style to NULL.
+
+Fri May 5 13:02:09 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcalendar.c:
+ * gtk/gtkbutton.c: ported _get_type() implementation over to
+ GType, either to preserve memchunks allocation facilities,
+ or because Gtk+ 1.0 GtkTypeInfo was still being used.
+
+ * gtk/gtkobject.[hc]: derive from GObject. ported various functions
+ over. prepare for ::destroy to be emitted multiple times.
+ removed reference tracer magic. chain into GObjectClass.shutdown()
+ to emit ::destroy signal.
+
+ * gtk/gtksignal.c: removed assumptions about GTK_TYPE_OBJECT being
+ fundamental.
+
+ * gtk/gtkmain.c: removed gtk_object_post_arg_parsing_init()
+ cludge.
+
+ * gtk/gtksocket.c:
+ * gtk/gtkplug.c:
+ * gtk/gtklayout.c:
+ * gtk/gtklabel.c:
+ * gtk/gtkargcollector.c:
+ * gtk/gtkarg.c: various fixups to work with GTK_TYPE_OBJECT
+ not being a fundamental anymore, and to work with the new
+ type system (nuked fundamental type varargs clutter).
+
+ * gtk/*.c: install finalize handlers in the GObjectClass
+ part of the class structure.
+ changed direct GTK_OBJECT()->klass accesses to
+ GTK_*_GET_CLASS().
+ changed direct object_class->type accesses to GTK_CLASS_TYPE().
+
+ * gtktypeutils.[hc]: use the reserved fundamental ids provided by
+ GType. made most of the GTK_*() type macros and Gtk* typedefs
+ simple wrappers around macros and types provided by GType.
+ most notably, a significant portion of the old API vanished:
+ GTK_TYPE_MAKE(),
+ GTK_TYPE_SEQNO(),
+ GTK_TYPE_FLAT_FIRST, GTK_TYPE_FLAT_LAST,
+ GTK_TYPE_STRUCTURED_FIRST, GTK_TYPE_STRUCTURED_LAST,
+ GTK_TYPE_ARGS,
+ GTK_TYPE_CALLBACK,
+ GTK_TYPE_C_CALLBACK,
+ GTK_TYPE_FOREIGN,
+ GtkTypeQuery,
+ gtk_type_query(),
+ gtk_type_set_varargs_type(),
+ gtk_type_get_varargs_type(),
+ gtk_type_check_object_cast(),
+ gtk_type_check_class_cast(),
+ gtk_type_describe_tree(),
+ gtk_type_describe_heritage(),
+ gtk_type_free(),
+ gtk_type_children_types(),
+ gtk_type_set_chunk_alloc(),
+ gtk_type_register_enum(),
+ gtk_type_register_flags(),
+ gtk_type_parent_class().
+ replacements, where available are described in ../docs/Changes-1.4.txt.
+ implemented compatibility functions for the remaining API.
+
+ * configure.in: depend on glib 1.3.1, use gobject module.
+
Thu May 11 12:39:50 2000 Owen Taylor <otaylor@redhat.com>
* TODO.xml: Various updates to current status.
+Fri May 12 17:13:32 2000 Tim Janik <timj@gtk.org>
+
+ * docs/Changes-1.4.txt: documented necessary changes for 1.4 transition.
+
+ * gtk/gtktext.c: made the adjustments no-construct args, simply
+ provide default adjustments.
+ (gtk_text_destroy): release adjustments.
+
+ * gtk/gtkprogressbar.c (gtk_progress_bar_class_init): made the
+ adjustment argument non-construct.
+
+ * gtk/gtkprogress.c (gtk_progress_destroy): release adjustment here,
+ instead of in finalize.
+ (gtk_progress_get_text_from_value):
+ (gtk_progress_get_current_text):
+ (gtk_progress_set_value):
+ (gtk_progress_get_percentage_from_value):
+ (gtk_progress_get_current_percentage):
+ (gtk_progress_set_percentage):
+ (gtk_progress_configure): ensure an adjustment is present.
+
+Thu May 11 01:24:08 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcolorsel.[hc]:
+ * gtk/gtkcolorseldialog.[hc]:
+ * gtk/gtkhsv.[hc]: major code cleanups, destroy handlers need to chain
+ their parent implementation, use bit fields for boolean values, don't
+ create unused widgets, usage of glib types, braces go on their own
+ lines, function argument alignment, #include directives etc. etc. etc..
+
+ * gtk/Makefile.am (gtk_public_h_sources): install gtkhsv.h.
+
+Wed May 10 23:29:52 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtktoolbar.c (gtk_toolbar_destroy): don't unref a NULL tooltips.
+
+ * gtk/gtkfilesel.c (gtk_file_selection_destroy): don't free a cmpl_state
+ of NULL.
+
+ * gtk/gtkcombo.c (gtk_combo_item_destroy): don#t keep references
+ to freed data.
+ (gtk_combo_destroy): don't keep a pointer to a destroyed window.
+
+ * gtk/gtkmenu.c (gtk_menu_init): reset the menu's toplevel pointer
+ to NULL when the toplevel is getting destroyed.
+ (gtk_menu_set_tearoff_state): same here for the tearoff_window.
+ (gtk_menu_destroy):
+ (gtk_menu_init): store the information of whether we have to
+ readd the initial child ref_count during destruction in a new
+ GtkMenu field needs_destruction_ref_count.
+
+ * gtk/gtkviewport.c: SHAME! ok this one is tricky, so i note it
+ here, those reading: learn from my mistake! ;)
+ in order for set_?adjustment to support a default adjustemnt if
+ invoked with an adjustment pointer of NULL, the code read (pseudo):
+ if (v->adjustment) unref (v->adjustment);
+ if (!adjustment) adjustment = adjustment_new ();
+ if (v->adjustment != adjustment) v->adjustment = ref (adjustment);
+ now imagine the first unref to actually free the old adjustment and
+ adjustment_new() creating a new adjustment from the very same memory
+ portion. here, the latter comparision will unintendedly fail, and
+ all hell breaks loose.
+ (gtk_viewport_set_hadjustment):
+ (gtk_viewport_set_vadjustment): reset viewport->?adjustment to NULL
+ after unreferencing it.
+
+ * gtk/gtkcontainer.[hc]: removed toplevel registration
+ functions: gtk_container_register_toplevel(),
+ gtk_container_unregister_toplevel() and
+ gtk_container_get_toplevels() which had wrong semantics
+ anyways: it didn't reference and copy the list.
+
+ * gtk/gtkwindow.c: we take over the container toplevel registration
+ bussiness now. windows are registered across multiple destructions,
+ untill they are finalized. the initial implicit reference count
+ users are holding on windows is removed with the first destruction
+ though.
+ (gtk_window_init): ref & sink and set has_user_ref_count, got
+ rid of gtk_container_register_toplevel() call. add window to
+ toplevel_list.
+ (gtk_window_destroy): unref the window if has_user_ref_count
+ is still set, got rid of call to
+ gtk_container_unregister_toplevel().
+ (gtk_window_finalize): remove window from toplevel list.
+ (gtk_window_list_toplevels): new function to return a newly
+ created list with referenced toplevels.
+ (gtk_window_read_rcfiles): use gtk_window_list_toplevels().
+
+ * gtk/gtkhscale.c (gtk_hscale_class_init): made the GtkRange
+ adjustment a non-construct arg.
+ * gtk/gtkvscale.c (gtk_vscale_class_init): likewise.
+ * gtk/gtkhscrollbar.c (gtk_vscrollbar_class_init): likewise.
+ * gtk/gtkvscrollbar.c (gtk_vscrollbar_class_init): likewise.
+
+ * gtk/gtkrange.c: added some realized checks.
+ (gtk_range_destroy): get rid of the h/v adjustments in the
+ destroy handler instead of finalize. remove timer.
+ (gtk_range_get_adjustment): demand create adjustment.
+
+ * gtk/gtkviewport.c: made h/v adjustment non-construct args.
+ we simply create them on demand now and get rid of them in
+ the destroy handler.
+ (gtk_viewport_destroy): get rid of the h/v adjustments in the
+ destroy handler instead of finalize.
+ (gtk_viewport_get_hadjustment):
+ (gtk_viewport_get_vadjustment):
+ (gtk_viewport_size_allocate): demand create h/v adjustment
+ if required.
+
+ * gtk/gtkwidget.c (gtk_widget_finalize): duplicate part of the
+ gtk_widget_real_destroy () functionality.
+ (gtk_widget_real_destroy): reinitialize with a new style, instead
+ of setting widget->style to NULL.
+
+Fri May 5 13:02:09 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcalendar.c:
+ * gtk/gtkbutton.c: ported _get_type() implementation over to
+ GType, either to preserve memchunks allocation facilities,
+ or because Gtk+ 1.0 GtkTypeInfo was still being used.
+
+ * gtk/gtkobject.[hc]: derive from GObject. ported various functions
+ over. prepare for ::destroy to be emitted multiple times.
+ removed reference tracer magic. chain into GObjectClass.shutdown()
+ to emit ::destroy signal.
+
+ * gtk/gtksignal.c: removed assumptions about GTK_TYPE_OBJECT being
+ fundamental.
+
+ * gtk/gtkmain.c: removed gtk_object_post_arg_parsing_init()
+ cludge.
+
+ * gtk/gtksocket.c:
+ * gtk/gtkplug.c:
+ * gtk/gtklayout.c:
+ * gtk/gtklabel.c:
+ * gtk/gtkargcollector.c:
+ * gtk/gtkarg.c: various fixups to work with GTK_TYPE_OBJECT
+ not being a fundamental anymore, and to work with the new
+ type system (nuked fundamental type varargs clutter).
+
+ * gtk/*.c: install finalize handlers in the GObjectClass
+ part of the class structure.
+ changed direct GTK_OBJECT()->klass accesses to
+ GTK_*_GET_CLASS().
+ changed direct object_class->type accesses to GTK_CLASS_TYPE().
+
+ * gtktypeutils.[hc]: use the reserved fundamental ids provided by
+ GType. made most of the GTK_*() type macros and Gtk* typedefs
+ simple wrappers around macros and types provided by GType.
+ most notably, a significant portion of the old API vanished:
+ GTK_TYPE_MAKE(),
+ GTK_TYPE_SEQNO(),
+ GTK_TYPE_FLAT_FIRST, GTK_TYPE_FLAT_LAST,
+ GTK_TYPE_STRUCTURED_FIRST, GTK_TYPE_STRUCTURED_LAST,
+ GTK_TYPE_ARGS,
+ GTK_TYPE_CALLBACK,
+ GTK_TYPE_C_CALLBACK,
+ GTK_TYPE_FOREIGN,
+ GtkTypeQuery,
+ gtk_type_query(),
+ gtk_type_set_varargs_type(),
+ gtk_type_get_varargs_type(),
+ gtk_type_check_object_cast(),
+ gtk_type_check_class_cast(),
+ gtk_type_describe_tree(),
+ gtk_type_describe_heritage(),
+ gtk_type_free(),
+ gtk_type_children_types(),
+ gtk_type_set_chunk_alloc(),
+ gtk_type_register_enum(),
+ gtk_type_register_flags(),
+ gtk_type_parent_class().
+ replacements, where available are described in ../docs/Changes-1.4.txt.
+ implemented compatibility functions for the remaining API.
+
+ * configure.in: depend on glib 1.3.1, use gobject module.
+
Thu May 11 12:39:50 2000 Owen Taylor <otaylor@redhat.com>
* TODO.xml: Various updates to current status.
+Fri May 12 17:13:32 2000 Tim Janik <timj@gtk.org>
+
+ * docs/Changes-1.4.txt: documented necessary changes for 1.4 transition.
+
+ * gtk/gtktext.c: made the adjustments no-construct args, simply
+ provide default adjustments.
+ (gtk_text_destroy): release adjustments.
+
+ * gtk/gtkprogressbar.c (gtk_progress_bar_class_init): made the
+ adjustment argument non-construct.
+
+ * gtk/gtkprogress.c (gtk_progress_destroy): release adjustment here,
+ instead of in finalize.
+ (gtk_progress_get_text_from_value):
+ (gtk_progress_get_current_text):
+ (gtk_progress_set_value):
+ (gtk_progress_get_percentage_from_value):
+ (gtk_progress_get_current_percentage):
+ (gtk_progress_set_percentage):
+ (gtk_progress_configure): ensure an adjustment is present.
+
+Thu May 11 01:24:08 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcolorsel.[hc]:
+ * gtk/gtkcolorseldialog.[hc]:
+ * gtk/gtkhsv.[hc]: major code cleanups, destroy handlers need to chain
+ their parent implementation, use bit fields for boolean values, don't
+ create unused widgets, usage of glib types, braces go on their own
+ lines, function argument alignment, #include directives etc. etc. etc..
+
+ * gtk/Makefile.am (gtk_public_h_sources): install gtkhsv.h.
+
+Wed May 10 23:29:52 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtktoolbar.c (gtk_toolbar_destroy): don't unref a NULL tooltips.
+
+ * gtk/gtkfilesel.c (gtk_file_selection_destroy): don't free a cmpl_state
+ of NULL.
+
+ * gtk/gtkcombo.c (gtk_combo_item_destroy): don#t keep references
+ to freed data.
+ (gtk_combo_destroy): don't keep a pointer to a destroyed window.
+
+ * gtk/gtkmenu.c (gtk_menu_init): reset the menu's toplevel pointer
+ to NULL when the toplevel is getting destroyed.
+ (gtk_menu_set_tearoff_state): same here for the tearoff_window.
+ (gtk_menu_destroy):
+ (gtk_menu_init): store the information of whether we have to
+ readd the initial child ref_count during destruction in a new
+ GtkMenu field needs_destruction_ref_count.
+
+ * gtk/gtkviewport.c: SHAME! ok this one is tricky, so i note it
+ here, those reading: learn from my mistake! ;)
+ in order for set_?adjustment to support a default adjustemnt if
+ invoked with an adjustment pointer of NULL, the code read (pseudo):
+ if (v->adjustment) unref (v->adjustment);
+ if (!adjustment) adjustment = adjustment_new ();
+ if (v->adjustment != adjustment) v->adjustment = ref (adjustment);
+ now imagine the first unref to actually free the old adjustment and
+ adjustment_new() creating a new adjustment from the very same memory
+ portion. here, the latter comparision will unintendedly fail, and
+ all hell breaks loose.
+ (gtk_viewport_set_hadjustment):
+ (gtk_viewport_set_vadjustment): reset viewport->?adjustment to NULL
+ after unreferencing it.
+
+ * gtk/gtkcontainer.[hc]: removed toplevel registration
+ functions: gtk_container_register_toplevel(),
+ gtk_container_unregister_toplevel() and
+ gtk_container_get_toplevels() which had wrong semantics
+ anyways: it didn't reference and copy the list.
+
+ * gtk/gtkwindow.c: we take over the container toplevel registration
+ bussiness now. windows are registered across multiple destructions,
+ untill they are finalized. the initial implicit reference count
+ users are holding on windows is removed with the first destruction
+ though.
+ (gtk_window_init): ref & sink and set has_user_ref_count, got
+ rid of gtk_container_register_toplevel() call. add window to
+ toplevel_list.
+ (gtk_window_destroy): unref the window if has_user_ref_count
+ is still set, got rid of call to
+ gtk_container_unregister_toplevel().
+ (gtk_window_finalize): remove window from toplevel list.
+ (gtk_window_list_toplevels): new function to return a newly
+ created list with referenced toplevels.
+ (gtk_window_read_rcfiles): use gtk_window_list_toplevels().
+
+ * gtk/gtkhscale.c (gtk_hscale_class_init): made the GtkRange
+ adjustment a non-construct arg.
+ * gtk/gtkvscale.c (gtk_vscale_class_init): likewise.
+ * gtk/gtkhscrollbar.c (gtk_vscrollbar_class_init): likewise.
+ * gtk/gtkvscrollbar.c (gtk_vscrollbar_class_init): likewise.
+
+ * gtk/gtkrange.c: added some realized checks.
+ (gtk_range_destroy): get rid of the h/v adjustments in the
+ destroy handler instead of finalize. remove timer.
+ (gtk_range_get_adjustment): demand create adjustment.
+
+ * gtk/gtkviewport.c: made h/v adjustment non-construct args.
+ we simply create them on demand now and get rid of them in
+ the destroy handler.
+ (gtk_viewport_destroy): get rid of the h/v adjustments in the
+ destroy handler instead of finalize.
+ (gtk_viewport_get_hadjustment):
+ (gtk_viewport_get_vadjustment):
+ (gtk_viewport_size_allocate): demand create h/v adjustment
+ if required.
+
+ * gtk/gtkwidget.c (gtk_widget_finalize): duplicate part of the
+ gtk_widget_real_destroy () functionality.
+ (gtk_widget_real_destroy): reinitialize with a new style, instead
+ of setting widget->style to NULL.
+
+Fri May 5 13:02:09 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcalendar.c:
+ * gtk/gtkbutton.c: ported _get_type() implementation over to
+ GType, either to preserve memchunks allocation facilities,
+ or because Gtk+ 1.0 GtkTypeInfo was still being used.
+
+ * gtk/gtkobject.[hc]: derive from GObject. ported various functions
+ over. prepare for ::destroy to be emitted multiple times.
+ removed reference tracer magic. chain into GObjectClass.shutdown()
+ to emit ::destroy signal.
+
+ * gtk/gtksignal.c: removed assumptions about GTK_TYPE_OBJECT being
+ fundamental.
+
+ * gtk/gtkmain.c: removed gtk_object_post_arg_parsing_init()
+ cludge.
+
+ * gtk/gtksocket.c:
+ * gtk/gtkplug.c:
+ * gtk/gtklayout.c:
+ * gtk/gtklabel.c:
+ * gtk/gtkargcollector.c:
+ * gtk/gtkarg.c: various fixups to work with GTK_TYPE_OBJECT
+ not being a fundamental anymore, and to work with the new
+ type system (nuked fundamental type varargs clutter).
+
+ * gtk/*.c: install finalize handlers in the GObjectClass
+ part of the class structure.
+ changed direct GTK_OBJECT()->klass accesses to
+ GTK_*_GET_CLASS().
+ changed direct object_class->type accesses to GTK_CLASS_TYPE().
+
+ * gtktypeutils.[hc]: use the reserved fundamental ids provided by
+ GType. made most of the GTK_*() type macros and Gtk* typedefs
+ simple wrappers around macros and types provided by GType.
+ most notably, a significant portion of the old API vanished:
+ GTK_TYPE_MAKE(),
+ GTK_TYPE_SEQNO(),
+ GTK_TYPE_FLAT_FIRST, GTK_TYPE_FLAT_LAST,
+ GTK_TYPE_STRUCTURED_FIRST, GTK_TYPE_STRUCTURED_LAST,
+ GTK_TYPE_ARGS,
+ GTK_TYPE_CALLBACK,
+ GTK_TYPE_C_CALLBACK,
+ GTK_TYPE_FOREIGN,
+ GtkTypeQuery,
+ gtk_type_query(),
+ gtk_type_set_varargs_type(),
+ gtk_type_get_varargs_type(),
+ gtk_type_check_object_cast(),
+ gtk_type_check_class_cast(),
+ gtk_type_describe_tree(),
+ gtk_type_describe_heritage(),
+ gtk_type_free(),
+ gtk_type_children_types(),
+ gtk_type_set_chunk_alloc(),
+ gtk_type_register_enum(),
+ gtk_type_register_flags(),
+ gtk_type_parent_class().
+ replacements, where available are described in ../docs/Changes-1.4.txt.
+ implemented compatibility functions for the remaining API.
+
+ * configure.in: depend on glib 1.3.1, use gobject module.
+
Thu May 11 12:39:50 2000 Owen Taylor <otaylor@redhat.com>
* TODO.xml: Various updates to current status.
+Fri May 12 17:13:32 2000 Tim Janik <timj@gtk.org>
+
+ * docs/Changes-1.4.txt: documented necessary changes for 1.4 transition.
+
+ * gtk/gtktext.c: made the adjustments no-construct args, simply
+ provide default adjustments.
+ (gtk_text_destroy): release adjustments.
+
+ * gtk/gtkprogressbar.c (gtk_progress_bar_class_init): made the
+ adjustment argument non-construct.
+
+ * gtk/gtkprogress.c (gtk_progress_destroy): release adjustment here,
+ instead of in finalize.
+ (gtk_progress_get_text_from_value):
+ (gtk_progress_get_current_text):
+ (gtk_progress_set_value):
+ (gtk_progress_get_percentage_from_value):
+ (gtk_progress_get_current_percentage):
+ (gtk_progress_set_percentage):
+ (gtk_progress_configure): ensure an adjustment is present.
+
+Thu May 11 01:24:08 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcolorsel.[hc]:
+ * gtk/gtkcolorseldialog.[hc]:
+ * gtk/gtkhsv.[hc]: major code cleanups, destroy handlers need to chain
+ their parent implementation, use bit fields for boolean values, don't
+ create unused widgets, usage of glib types, braces go on their own
+ lines, function argument alignment, #include directives etc. etc. etc..
+
+ * gtk/Makefile.am (gtk_public_h_sources): install gtkhsv.h.
+
+Wed May 10 23:29:52 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtktoolbar.c (gtk_toolbar_destroy): don't unref a NULL tooltips.
+
+ * gtk/gtkfilesel.c (gtk_file_selection_destroy): don't free a cmpl_state
+ of NULL.
+
+ * gtk/gtkcombo.c (gtk_combo_item_destroy): don#t keep references
+ to freed data.
+ (gtk_combo_destroy): don't keep a pointer to a destroyed window.
+
+ * gtk/gtkmenu.c (gtk_menu_init): reset the menu's toplevel pointer
+ to NULL when the toplevel is getting destroyed.
+ (gtk_menu_set_tearoff_state): same here for the tearoff_window.
+ (gtk_menu_destroy):
+ (gtk_menu_init): store the information of whether we have to
+ readd the initial child ref_count during destruction in a new
+ GtkMenu field needs_destruction_ref_count.
+
+ * gtk/gtkviewport.c: SHAME! ok this one is tricky, so i note it
+ here, those reading: learn from my mistake! ;)
+ in order for set_?adjustment to support a default adjustemnt if
+ invoked with an adjustment pointer of NULL, the code read (pseudo):
+ if (v->adjustment) unref (v->adjustment);
+ if (!adjustment) adjustment = adjustment_new ();
+ if (v->adjustment != adjustment) v->adjustment = ref (adjustment);
+ now imagine the first unref to actually free the old adjustment and
+ adjustment_new() creating a new adjustment from the very same memory
+ portion. here, the latter comparision will unintendedly fail, and
+ all hell breaks loose.
+ (gtk_viewport_set_hadjustment):
+ (gtk_viewport_set_vadjustment): reset viewport->?adjustment to NULL
+ after unreferencing it.
+
+ * gtk/gtkcontainer.[hc]: removed toplevel registration
+ functions: gtk_container_register_toplevel(),
+ gtk_container_unregister_toplevel() and
+ gtk_container_get_toplevels() which had wrong semantics
+ anyways: it didn't reference and copy the list.
+
+ * gtk/gtkwindow.c: we take over the container toplevel registration
+ bussiness now. windows are registered across multiple destructions,
+ untill they are finalized. the initial implicit reference count
+ users are holding on windows is removed with the first destruction
+ though.
+ (gtk_window_init): ref & sink and set has_user_ref_count, got
+ rid of gtk_container_register_toplevel() call. add window to
+ toplevel_list.
+ (gtk_window_destroy): unref the window if has_user_ref_count
+ is still set, got rid of call to
+ gtk_container_unregister_toplevel().
+ (gtk_window_finalize): remove window from toplevel list.
+ (gtk_window_list_toplevels): new function to return a newly
+ created list with referenced toplevels.
+ (gtk_window_read_rcfiles): use gtk_window_list_toplevels().
+
+ * gtk/gtkhscale.c (gtk_hscale_class_init): made the GtkRange
+ adjustment a non-construct arg.
+ * gtk/gtkvscale.c (gtk_vscale_class_init): likewise.
+ * gtk/gtkhscrollbar.c (gtk_vscrollbar_class_init): likewise.
+ * gtk/gtkvscrollbar.c (gtk_vscrollbar_class_init): likewise.
+
+ * gtk/gtkrange.c: added some realized checks.
+ (gtk_range_destroy): get rid of the h/v adjustments in the
+ destroy handler instead of finalize. remove timer.
+ (gtk_range_get_adjustment): demand create adjustment.
+
+ * gtk/gtkviewport.c: made h/v adjustment non-construct args.
+ we simply create them on demand now and get rid of them in
+ the destroy handler.
+ (gtk_viewport_destroy): get rid of the h/v adjustments in the
+ destroy handler instead of finalize.
+ (gtk_viewport_get_hadjustment):
+ (gtk_viewport_get_vadjustment):
+ (gtk_viewport_size_allocate): demand create h/v adjustment
+ if required.
+
+ * gtk/gtkwidget.c (gtk_widget_finalize): duplicate part of the
+ gtk_widget_real_destroy () functionality.
+ (gtk_widget_real_destroy): reinitialize with a new style, instead
+ of setting widget->style to NULL.
+
+Fri May 5 13:02:09 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcalendar.c:
+ * gtk/gtkbutton.c: ported _get_type() implementation over to
+ GType, either to preserve memchunks allocation facilities,
+ or because Gtk+ 1.0 GtkTypeInfo was still being used.
+
+ * gtk/gtkobject.[hc]: derive from GObject. ported various functions
+ over. prepare for ::destroy to be emitted multiple times.
+ removed reference tracer magic. chain into GObjectClass.shutdown()
+ to emit ::destroy signal.
+
+ * gtk/gtksignal.c: removed assumptions about GTK_TYPE_OBJECT being
+ fundamental.
+
+ * gtk/gtkmain.c: removed gtk_object_post_arg_parsing_init()
+ cludge.
+
+ * gtk/gtksocket.c:
+ * gtk/gtkplug.c:
+ * gtk/gtklayout.c:
+ * gtk/gtklabel.c:
+ * gtk/gtkargcollector.c:
+ * gtk/gtkarg.c: various fixups to work with GTK_TYPE_OBJECT
+ not being a fundamental anymore, and to work with the new
+ type system (nuked fundamental type varargs clutter).
+
+ * gtk/*.c: install finalize handlers in the GObjectClass
+ part of the class structure.
+ changed direct GTK_OBJECT()->klass accesses to
+ GTK_*_GET_CLASS().
+ changed direct object_class->type accesses to GTK_CLASS_TYPE().
+
+ * gtktypeutils.[hc]: use the reserved fundamental ids provided by
+ GType. made most of the GTK_*() type macros and Gtk* typedefs
+ simple wrappers around macros and types provided by GType.
+ most notably, a significant portion of the old API vanished:
+ GTK_TYPE_MAKE(),
+ GTK_TYPE_SEQNO(),
+ GTK_TYPE_FLAT_FIRST, GTK_TYPE_FLAT_LAST,
+ GTK_TYPE_STRUCTURED_FIRST, GTK_TYPE_STRUCTURED_LAST,
+ GTK_TYPE_ARGS,
+ GTK_TYPE_CALLBACK,
+ GTK_TYPE_C_CALLBACK,
+ GTK_TYPE_FOREIGN,
+ GtkTypeQuery,
+ gtk_type_query(),
+ gtk_type_set_varargs_type(),
+ gtk_type_get_varargs_type(),
+ gtk_type_check_object_cast(),
+ gtk_type_check_class_cast(),
+ gtk_type_describe_tree(),
+ gtk_type_describe_heritage(),
+ gtk_type_free(),
+ gtk_type_children_types(),
+ gtk_type_set_chunk_alloc(),
+ gtk_type_register_enum(),
+ gtk_type_register_flags(),
+ gtk_type_parent_class().
+ replacements, where available are described in ../docs/Changes-1.4.txt.
+ implemented compatibility functions for the remaining API.
+
+ * configure.in: depend on glib 1.3.1, use gobject module.
+
Thu May 11 12:39:50 2000 Owen Taylor <otaylor@redhat.com>
* TODO.xml: Various updates to current status.
+Fri May 12 17:13:32 2000 Tim Janik <timj@gtk.org>
+
+ * docs/Changes-1.4.txt: documented necessary changes for 1.4 transition.
+
+ * gtk/gtktext.c: made the adjustments no-construct args, simply
+ provide default adjustments.
+ (gtk_text_destroy): release adjustments.
+
+ * gtk/gtkprogressbar.c (gtk_progress_bar_class_init): made the
+ adjustment argument non-construct.
+
+ * gtk/gtkprogress.c (gtk_progress_destroy): release adjustment here,
+ instead of in finalize.
+ (gtk_progress_get_text_from_value):
+ (gtk_progress_get_current_text):
+ (gtk_progress_set_value):
+ (gtk_progress_get_percentage_from_value):
+ (gtk_progress_get_current_percentage):
+ (gtk_progress_set_percentage):
+ (gtk_progress_configure): ensure an adjustment is present.
+
+Thu May 11 01:24:08 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcolorsel.[hc]:
+ * gtk/gtkcolorseldialog.[hc]:
+ * gtk/gtkhsv.[hc]: major code cleanups, destroy handlers need to chain
+ their parent implementation, use bit fields for boolean values, don't
+ create unused widgets, usage of glib types, braces go on their own
+ lines, function argument alignment, #include directives etc. etc. etc..
+
+ * gtk/Makefile.am (gtk_public_h_sources): install gtkhsv.h.
+
+Wed May 10 23:29:52 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtktoolbar.c (gtk_toolbar_destroy): don't unref a NULL tooltips.
+
+ * gtk/gtkfilesel.c (gtk_file_selection_destroy): don't free a cmpl_state
+ of NULL.
+
+ * gtk/gtkcombo.c (gtk_combo_item_destroy): don#t keep references
+ to freed data.
+ (gtk_combo_destroy): don't keep a pointer to a destroyed window.
+
+ * gtk/gtkmenu.c (gtk_menu_init): reset the menu's toplevel pointer
+ to NULL when the toplevel is getting destroyed.
+ (gtk_menu_set_tearoff_state): same here for the tearoff_window.
+ (gtk_menu_destroy):
+ (gtk_menu_init): store the information of whether we have to
+ readd the initial child ref_count during destruction in a new
+ GtkMenu field needs_destruction_ref_count.
+
+ * gtk/gtkviewport.c: SHAME! ok this one is tricky, so i note it
+ here, those reading: learn from my mistake! ;)
+ in order for set_?adjustment to support a default adjustemnt if
+ invoked with an adjustment pointer of NULL, the code read (pseudo):
+ if (v->adjustment) unref (v->adjustment);
+ if (!adjustment) adjustment = adjustment_new ();
+ if (v->adjustment != adjustment) v->adjustment = ref (adjustment);
+ now imagine the first unref to actually free the old adjustment and
+ adjustment_new() creating a new adjustment from the very same memory
+ portion. here, the latter comparision will unintendedly fail, and
+ all hell breaks loose.
+ (gtk_viewport_set_hadjustment):
+ (gtk_viewport_set_vadjustment): reset viewport->?adjustment to NULL
+ after unreferencing it.
+
+ * gtk/gtkcontainer.[hc]: removed toplevel registration
+ functions: gtk_container_register_toplevel(),
+ gtk_container_unregister_toplevel() and
+ gtk_container_get_toplevels() which had wrong semantics
+ anyways: it didn't reference and copy the list.
+
+ * gtk/gtkwindow.c: we take over the container toplevel registration
+ bussiness now. windows are registered across multiple destructions,
+ untill they are finalized. the initial implicit reference count
+ users are holding on windows is removed with the first destruction
+ though.
+ (gtk_window_init): ref & sink and set has_user_ref_count, got
+ rid of gtk_container_register_toplevel() call. add window to
+ toplevel_list.
+ (gtk_window_destroy): unref the window if has_user_ref_count
+ is still set, got rid of call to
+ gtk_container_unregister_toplevel().
+ (gtk_window_finalize): remove window from toplevel list.
+ (gtk_window_list_toplevels): new function to return a newly
+ created list with referenced toplevels.
+ (gtk_window_read_rcfiles): use gtk_window_list_toplevels().
+
+ * gtk/gtkhscale.c (gtk_hscale_class_init): made the GtkRange
+ adjustment a non-construct arg.
+ * gtk/gtkvscale.c (gtk_vscale_class_init): likewise.
+ * gtk/gtkhscrollbar.c (gtk_vscrollbar_class_init): likewise.
+ * gtk/gtkvscrollbar.c (gtk_vscrollbar_class_init): likewise.
+
+ * gtk/gtkrange.c: added some realized checks.
+ (gtk_range_destroy): get rid of the h/v adjustments in the
+ destroy handler instead of finalize. remove timer.
+ (gtk_range_get_adjustment): demand create adjustment.
+
+ * gtk/gtkviewport.c: made h/v adjustment non-construct args.
+ we simply create them on demand now and get rid of them in
+ the destroy handler.
+ (gtk_viewport_destroy): get rid of the h/v adjustments in the
+ destroy handler instead of finalize.
+ (gtk_viewport_get_hadjustment):
+ (gtk_viewport_get_vadjustment):
+ (gtk_viewport_size_allocate): demand create h/v adjustment
+ if required.
+
+ * gtk/gtkwidget.c (gtk_widget_finalize): duplicate part of the
+ gtk_widget_real_destroy () functionality.
+ (gtk_widget_real_destroy): reinitialize with a new style, instead
+ of setting widget->style to NULL.
+
+Fri May 5 13:02:09 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcalendar.c:
+ * gtk/gtkbutton.c: ported _get_type() implementation over to
+ GType, either to preserve memchunks allocation facilities,
+ or because Gtk+ 1.0 GtkTypeInfo was still being used.
+
+ * gtk/gtkobject.[hc]: derive from GObject. ported various functions
+ over. prepare for ::destroy to be emitted multiple times.
+ removed reference tracer magic. chain into GObjectClass.shutdown()
+ to emit ::destroy signal.
+
+ * gtk/gtksignal.c: removed assumptions about GTK_TYPE_OBJECT being
+ fundamental.
+
+ * gtk/gtkmain.c: removed gtk_object_post_arg_parsing_init()
+ cludge.
+
+ * gtk/gtksocket.c:
+ * gtk/gtkplug.c:
+ * gtk/gtklayout.c:
+ * gtk/gtklabel.c:
+ * gtk/gtkargcollector.c:
+ * gtk/gtkarg.c: various fixups to work with GTK_TYPE_OBJECT
+ not being a fundamental anymore, and to work with the new
+ type system (nuked fundamental type varargs clutter).
+
+ * gtk/*.c: install finalize handlers in the GObjectClass
+ part of the class structure.
+ changed direct GTK_OBJECT()->klass accesses to
+ GTK_*_GET_CLASS().
+ changed direct object_class->type accesses to GTK_CLASS_TYPE().
+
+ * gtktypeutils.[hc]: use the reserved fundamental ids provided by
+ GType. made most of the GTK_*() type macros and Gtk* typedefs
+ simple wrappers around macros and types provided by GType.
+ most notably, a significant portion of the old API vanished:
+ GTK_TYPE_MAKE(),
+ GTK_TYPE_SEQNO(),
+ GTK_TYPE_FLAT_FIRST, GTK_TYPE_FLAT_LAST,
+ GTK_TYPE_STRUCTURED_FIRST, GTK_TYPE_STRUCTURED_LAST,
+ GTK_TYPE_ARGS,
+ GTK_TYPE_CALLBACK,
+ GTK_TYPE_C_CALLBACK,
+ GTK_TYPE_FOREIGN,
+ GtkTypeQuery,
+ gtk_type_query(),
+ gtk_type_set_varargs_type(),
+ gtk_type_get_varargs_type(),
+ gtk_type_check_object_cast(),
+ gtk_type_check_class_cast(),
+ gtk_type_describe_tree(),
+ gtk_type_describe_heritage(),
+ gtk_type_free(),
+ gtk_type_children_types(),
+ gtk_type_set_chunk_alloc(),
+ gtk_type_register_enum(),
+ gtk_type_register_flags(),
+ gtk_type_parent_class().
+ replacements, where available are described in ../docs/Changes-1.4.txt.
+ implemented compatibility functions for the remaining API.
+
+ * configure.in: depend on glib 1.3.1, use gobject module.
+
Thu May 11 12:39:50 2000 Owen Taylor <otaylor@redhat.com>
* TODO.xml: Various updates to current status.
+Fri May 12 17:13:32 2000 Tim Janik <timj@gtk.org>
+
+ * docs/Changes-1.4.txt: documented necessary changes for 1.4 transition.
+
+ * gtk/gtktext.c: made the adjustments no-construct args, simply
+ provide default adjustments.
+ (gtk_text_destroy): release adjustments.
+
+ * gtk/gtkprogressbar.c (gtk_progress_bar_class_init): made the
+ adjustment argument non-construct.
+
+ * gtk/gtkprogress.c (gtk_progress_destroy): release adjustment here,
+ instead of in finalize.
+ (gtk_progress_get_text_from_value):
+ (gtk_progress_get_current_text):
+ (gtk_progress_set_value):
+ (gtk_progress_get_percentage_from_value):
+ (gtk_progress_get_current_percentage):
+ (gtk_progress_set_percentage):
+ (gtk_progress_configure): ensure an adjustment is present.
+
+Thu May 11 01:24:08 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcolorsel.[hc]:
+ * gtk/gtkcolorseldialog.[hc]:
+ * gtk/gtkhsv.[hc]: major code cleanups, destroy handlers need to chain
+ their parent implementation, use bit fields for boolean values, don't
+ create unused widgets, usage of glib types, braces go on their own
+ lines, function argument alignment, #include directives etc. etc. etc..
+
+ * gtk/Makefile.am (gtk_public_h_sources): install gtkhsv.h.
+
+Wed May 10 23:29:52 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtktoolbar.c (gtk_toolbar_destroy): don't unref a NULL tooltips.
+
+ * gtk/gtkfilesel.c (gtk_file_selection_destroy): don't free a cmpl_state
+ of NULL.
+
+ * gtk/gtkcombo.c (gtk_combo_item_destroy): don#t keep references
+ to freed data.
+ (gtk_combo_destroy): don't keep a pointer to a destroyed window.
+
+ * gtk/gtkmenu.c (gtk_menu_init): reset the menu's toplevel pointer
+ to NULL when the toplevel is getting destroyed.
+ (gtk_menu_set_tearoff_state): same here for the tearoff_window.
+ (gtk_menu_destroy):
+ (gtk_menu_init): store the information of whether we have to
+ readd the initial child ref_count during destruction in a new
+ GtkMenu field needs_destruction_ref_count.
+
+ * gtk/gtkviewport.c: SHAME! ok this one is tricky, so i note it
+ here, those reading: learn from my mistake! ;)
+ in order for set_?adjustment to support a default adjustemnt if
+ invoked with an adjustment pointer of NULL, the code read (pseudo):
+ if (v->adjustment) unref (v->adjustment);
+ if (!adjustment) adjustment = adjustment_new ();
+ if (v->adjustment != adjustment) v->adjustment = ref (adjustment);
+ now imagine the first unref to actually free the old adjustment and
+ adjustment_new() creating a new adjustment from the very same memory
+ portion. here, the latter comparision will unintendedly fail, and
+ all hell breaks loose.
+ (gtk_viewport_set_hadjustment):
+ (gtk_viewport_set_vadjustment): reset viewport->?adjustment to NULL
+ after unreferencing it.
+
+ * gtk/gtkcontainer.[hc]: removed toplevel registration
+ functions: gtk_container_register_toplevel(),
+ gtk_container_unregister_toplevel() and
+ gtk_container_get_toplevels() which had wrong semantics
+ anyways: it didn't reference and copy the list.
+
+ * gtk/gtkwindow.c: we take over the container toplevel registration
+ bussiness now. windows are registered across multiple destructions,
+ untill they are finalized. the initial implicit reference count
+ users are holding on windows is removed with the first destruction
+ though.
+ (gtk_window_init): ref & sink and set has_user_ref_count, got
+ rid of gtk_container_register_toplevel() call. add window to
+ toplevel_list.
+ (gtk_window_destroy): unref the window if has_user_ref_count
+ is still set, got rid of call to
+ gtk_container_unregister_toplevel().
+ (gtk_window_finalize): remove window from toplevel list.
+ (gtk_window_list_toplevels): new function to return a newly
+ created list with referenced toplevels.
+ (gtk_window_read_rcfiles): use gtk_window_list_toplevels().
+
+ * gtk/gtkhscale.c (gtk_hscale_class_init): made the GtkRange
+ adjustment a non-construct arg.
+ * gtk/gtkvscale.c (gtk_vscale_class_init): likewise.
+ * gtk/gtkhscrollbar.c (gtk_vscrollbar_class_init): likewise.
+ * gtk/gtkvscrollbar.c (gtk_vscrollbar_class_init): likewise.
+
+ * gtk/gtkrange.c: added some realized checks.
+ (gtk_range_destroy): get rid of the h/v adjustments in the
+ destroy handler instead of finalize. remove timer.
+ (gtk_range_get_adjustment): demand create adjustment.
+
+ * gtk/gtkviewport.c: made h/v adjustment non-construct args.
+ we simply create them on demand now and get rid of them in
+ the destroy handler.
+ (gtk_viewport_destroy): get rid of the h/v adjustments in the
+ destroy handler instead of finalize.
+ (gtk_viewport_get_hadjustment):
+ (gtk_viewport_get_vadjustment):
+ (gtk_viewport_size_allocate): demand create h/v adjustment
+ if required.
+
+ * gtk/gtkwidget.c (gtk_widget_finalize): duplicate part of the
+ gtk_widget_real_destroy () functionality.
+ (gtk_widget_real_destroy): reinitialize with a new style, instead
+ of setting widget->style to NULL.
+
+Fri May 5 13:02:09 2000 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcalendar.c:
+ * gtk/gtkbutton.c: ported _get_type() implementation over to
+ GType, either to preserve memchunks allocation facilities,
+ or because Gtk+ 1.0 GtkTypeInfo was still being used.
+
+ * gtk/gtkobject.[hc]: derive from GObject. ported various functions
+ over. prepare for ::destroy to be emitted multiple times.
+ removed reference tracer magic. chain into GObjectClass.shutdown()
+ to emit ::destroy signal.
+
+ * gtk/gtksignal.c: removed assumptions about GTK_TYPE_OBJECT being
+ fundamental.
+
+ * gtk/gtkmain.c: removed gtk_object_post_arg_parsing_init()
+ cludge.
+
+ * gtk/gtksocket.c:
+ * gtk/gtkplug.c:
+ * gtk/gtklayout.c:
+ * gtk/gtklabel.c:
+ * gtk/gtkargcollector.c:
+ * gtk/gtkarg.c: various fixups to work with GTK_TYPE_OBJECT
+ not being a fundamental anymore, and to work with the new
+ type system (nuked fundamental type varargs clutter).
+
+ * gtk/*.c: install finalize handlers in the GObjectClass
+ part of the class structure.
+ changed direct GTK_OBJECT()->klass accesses to
+ GTK_*_GET_CLASS().
+ changed direct object_class->type accesses to GTK_CLASS_TYPE().
+
+ * gtktypeutils.[hc]: use the reserved fundamental ids provided by
+ GType. made most of the GTK_*() type macros and Gtk* typedefs
+ simple wrappers around macros and types provided by GType.
+ most notably, a significant portion of the old API vanished:
+ GTK_TYPE_MAKE(),
+ GTK_TYPE_SEQNO(),
+ GTK_TYPE_FLAT_FIRST, GTK_TYPE_FLAT_LAST,
+ GTK_TYPE_STRUCTURED_FIRST, GTK_TYPE_STRUCTURED_LAST,
+ GTK_TYPE_ARGS,
+ GTK_TYPE_CALLBACK,
+ GTK_TYPE_C_CALLBACK,
+ GTK_TYPE_FOREIGN,
+ GtkTypeQuery,
+ gtk_type_query(),
+ gtk_type_set_varargs_type(),
+ gtk_type_get_varargs_type(),
+ gtk_type_check_object_cast(),
+ gtk_type_check_class_cast(),
+ gtk_type_describe_tree(),
+ gtk_type_describe_heritage(),
+ gtk_type_free(),
+ gtk_type_children_types(),
+ gtk_type_set_chunk_alloc(),
+ gtk_type_register_enum(),
+ gtk_type_register_flags(),
+ gtk_type_parent_class().
+ replacements, where available are described in ../docs/Changes-1.4.txt.
+ implemented compatibility functions for the remaining API.
+
+ * configure.in: depend on glib 1.3.1, use gobject module.
+
Thu May 11 12:39:50 2000 Owen Taylor <otaylor@redhat.com>
* TODO.xml: Various updates to current status.
if test x$with_glib = x ; then
# Look for separately installed glib
- AM_PATH_GLIB(1.3.0,,
+ AM_PATH_GLIB(1.3.1,,
AC_MSG_ERROR([
*** GLIB 1.3.0 or better is required. The latest version of GLIB
*** is always available from ftp://ftp.gtk.org/.]),
- gmodule gthread)
+ gobject gmodule gthread)
# we do not want to make all gtk progs to link to thread libraries.
- glib_cflags=`$GLIB_CONFIG glib gmodule --cflags`
+ glib_cflags=`$GLIB_CONFIG glib gobject gmodule --cflags`
glib_thread_cflags="$GLIB_CFLAGS"
- glib_libs=`$GLIB_CONFIG glib gmodule --libs`
+ glib_libs=`$GLIB_CONFIG glib gobject gmodule --libs`
glib_thread_libs="$GLIB_LIBS"
GLIB_LIBS="$glib_libs"
GLIB_DEPLIBS="$glib_libs"
Incompatible Changes from GTK+-1.2 to GTK+-1.4:
-- The gdk_time* functions have been removed. This functionality
+* The gdk_time* functions have been removed. This functionality
has been unused since the main loop was moved into GLib
prior to 1.2.
-- The signature for GtkPrintFunc (used for gtk_item_factory_dump_items)
+* The signature for GtkPrintFunc (used for gtk_item_factory_dump_items)
has been changed to take a 'const gchar *' instead of 'gchar *', to
match what we do for glib, and other similar cases.
-- The detail arguments in the GtkStyleClass structure are now 'const gchar *'.
+* The detail arguments in the GtkStyleClass structure are now 'const gchar *'.
-- gtk_paned_set_gutter_size() has been removed, since the small handle tab
+* gtk_paned_set_gutter_size() has been removed, since the small handle tab
has been changed to include the entire area previously occupied by
the gutter.
-- GDK no longer selects OwnerGrabButtonMask for button presses. This means
+* GDK no longer selects OwnerGrabButtonMask for button presses. This means
that the automatic grab that occurs when the user presses a button
will have owner_events = FALSE, so all events are redirected to the
grab window, even events that would normally go to other windows of the
window's owner.
-- The detail arguments in the GtkStyleClass structure are now 'const gchar *'.
+* GtkColorSelectionDialog has now been moved into it's own set of files,
+ gtkcolorseldialog.c and gtkcolorseldialog.h.
-- GtkColorSelectionDialog has now been moved into it's own set of files,
-gtkcolorseldialog.c and gtkcolorseldialog.h.
+* Type system changes:
+ - GTK_TYPE_OBJECT is not a fundamental type anymore. Type checks of the
+ style (GTK_FUNDAMENTAL_TYPE (some_type) == GTK_TYPE_OBJECT)
+ will not work anymore. As a replacement, (GTK_TYPE_IS_OBJECT (some_type))
+ can be used now.
+ - The following types vanished: GTK_TYPE_ARGS, GTK_TYPE_CALLBACK,
+ GTK_TYPE_C_CALLBACK, GTK_TYPE_FOREIGN. With them, the corresponding GtkARg
+ fields and field access macros vanished as well.
+ - The following type aliases vanished: GTK_TYPE_FLAT_FIRST,
+ GTK_TYPE_FLAT_LAST, GTK_TYPE_STRUCTURED_FIRST, GTK_TYPE_STRUCTURED_LAST.
+ - The type macros GTK_TYPE_MAKE() and GTK_TYPE_SEQNO() vanished, use of
+ GTK_FUNDAMENTAL_TYPE() is discouraged. Instead, the corresponding GType
+ API should be used: G_TYPE_FUNDAMENTAL(), G_TYPE_DERIVE_ID(),
+ G_TYPE_BRANCH_SEQNO(). Note that the GLib type system doesn't build new
+ type ids based on a global incremental sequential number anymore, but
+ numbers new type ids sequentially per fundamental type branch.
+ - The following type functions vanished/were replaced:
+ Old Function Replacement
+ gtk_type_query() - being investigated -
+ gtk_type_set_varargs_type() -
+ gtk_type_get_varargs_type() -
+ gtk_type_check_object_cast() g_type_check_instance_cast()
+ gtk_type_check_class_cast() g_type_check_class_cast()
+ gtk_type_describe_tree() -
+ gtk_type_describe_heritage() -
+ gtk_type_free() -
+ gtk_type_children_types() g_type_children()
+ gtk_type_set_chunk_alloc() GTypeInfo.n_preallocs
+ gtk_type_register_enum() g_enum_register_static()
+ gtk_type_register_flags() g_flags_register_static()
+ gtk_type_parent_class() g_type_parent() / g_type_class_peek_parent()
+ Use of g_type_class_ref() / g_type_class_unref() and g_type_class_peek()
+ is recommended over usage of gtk_type_class().
+ Use of g_type_register_static() / g_type_register_dynamic() is recommended
+ over usage of gtk_type_unique().
+
+* Object system changes:
+ GtkObject derives from GObject, it is not the basic object type anymore.
+ This imposes the following source incompatible changes:
+ - GtkObject has no klass field anymore, an object's class can be retrived
+ with the object's coresponding GTK_<OBJECT>_GET_CLASS (object) macro.
+ - GtkObjectClass has no type field anymore, a class's type can be retrived
+ with the GTK_CLASS_TYPE (class) macro.
+ - GtkObjectClass does not introduce the finalize() or shutdown() method
+ anymore. While shutdown() is intended for Gtk internal use only, finalize()
+ is required by a variety of object implementations. GObjectClass.finalize
+ should be overriden here, e.g.:
+ static void gtk_label_finalize (GObject *gobject)
+ {
+ GtkLabel *label = GTK_LABEL (gobject);
+
+ G_OBJECT_CLASS (parent_class)->finalize (object);
+ }
+ static void gtk_label_class_init (GtkLabelClass *class)
+ {
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+
+ gobject_class->finalize = gtk_label_finalize;
+ }
+ - the GtkObject::destroy signal can be emitted multiple times on an object
+ now. ::destroy implementations have to take this into account by
+ conditionalising freeing/release of assorted resources, e.g.:
+ if (object->foo_data)
+ {
+ g_free (object->foo_data);
+ object->foo_data = NULL;
+ }
+ Also, ::destroy implementations have to release peding object references,
+ that is, code portions commonly found in finalize implementations like:
+ if (object->adjustment)
+ {
+ gtk_object_unref (object->adjustment);
+ object->adjustment = NULL;
+ }
+ have to be moved into the ::destroy implementations.
+ This is required to break object reference cycles at destruction time.
gtkhscale.h \
gtkhscrollbar.h \
gtkhseparator.h \
+ gtkhsv.h \
gtkimage.h \
gtkinputdialog.h \
gtkinvisible.h \
"OBJECT"=>"gpointer",
# complex types. These need special handling.
- "FOREIGN"=>"FOREIGN",
- "C_CALLBACK"=>"C_CALLBACK",
- "SIGNAL"=>"SIGNAL",
- "ARGS"=>"ARGS",
- "CALLBACK"=>"CALLBACK"
+ "SIGNAL"=>"SIGNAL"
);
if ($#ARGV != 2) {
print OS "typedef $trans{$retval} (*GtkSignal_$funcname) (GtkObject *object, \n";
$argn = 1;
for (@params) {
- if($_ eq "C_CALLBACK") {
- print OS "gpointer arg".$argn."a,\n";
- print OS "gpointer arg".$argn."b,\n";
- $argn++;
- } elsif($_ eq "SIGNAL") {
- print OS "gpointer arg".$argn."a,\n";
- print OS "gpointer arg".$argn."b,\n";
- $argn++;
- } elsif($_ eq "ARGS") {
- print OS "gpointer arg".$argn."a,\n";
- print OS "gpointer arg".$argn."b,\n";
- $argn++;
- } elsif($_ eq "CALLBACK") {
- print OS "gpointer arg".$argn."a,\n";
- print OS "gpointer arg".$argn."b,\n";
- print OS "gpointer arg".$argn."c,\n";
- $argn++;
- } elsif($_ eq "FOREIGN") {
+ if($_ eq "SIGNAL") {
print OS "gpointer arg".$argn."a,\n";
print OS "gpointer arg".$argn."b,\n";
$argn++;
print OS " (* rfunc) (object,\n";
for($i = 0; $i < (scalar @params); $i++) {
- if($params[$i] eq "C_CALLBACK") {
- print OS <<EOT;
-GTK_VALUE_C_CALLBACK(args[$i]).func,
-GTK_VALUE_C_CALLBACK(args[$i]).func_data,
-EOT
- } elsif ($params[$i] eq "SIGNAL") {
+ if ($params[$i] eq "SIGNAL") {
print OS <<EOT;
GTK_VALUE_SIGNAL(args[$i]).f,
GTK_VALUE_SIGNAL(args[$i]).d,
-EOT
- } elsif ($params[$i] eq "CALLBACK") {
- print OS <<EOT;
-GTK_VALUE_CALLBACK(args[$i]).marshal,
-GTK_VALUE_CALLBACK(args[$i]).data,
-GTK_VALUE_CALLBACK(args[$i]).notify,
-EOT
- } elsif ($params[$i] eq "FOREIGN") {
- print OS <<EOT;
-GTK_VALUE_FOREIGN(args[$i]).data,
-GTK_VALUE_FOREIGN(args[$i]).notify,
EOT
} elsif ($params[$i] eq "NONE") {
} else {
gtk_marshal_INT__POINTER
gtk_marshal_INT__POINTER_CHAR_CHAR
gtk_marshal_NONE__BOOL
- gtk_marshal_NONE__C_CALLBACK
- gtk_marshal_NONE__C_CALLBACK_C_CALLBACK
gtk_marshal_NONE__INT
gtk_marshal_NONE__INT_FLOAT
gtk_marshal_NONE__INT_FLOAT_BOOL
GtkSignalRunType signal_flags,
guint handler_offset)
{
- g_return_val_if_fail (gtk_type_is_a (class_type, GTK_TYPE_OBJECT), 0);
+ g_return_val_if_fail (GTK_TYPE_IS_OBJECT (class_type), 0);
return gtk_signal_new ("add-accelerator",
signal_flags,
GtkSignalRunType signal_flags,
guint handler_offset)
{
- g_return_val_if_fail (gtk_type_is_a (class_type, GTK_TYPE_OBJECT), 0);
+ g_return_val_if_fail (GTK_TYPE_IS_OBJECT (class_type), 0);
return gtk_signal_new ("remove-accelerator",
signal_flags,
GtkArg *arg,
guint arg_id);
static void gtk_accel_label_destroy (GtkObject *object);
-static void gtk_accel_label_finalize (GtkObject *object);
+static void gtk_accel_label_finalize (GObject *object);
static void gtk_accel_label_size_request (GtkWidget *widget,
GtkRequisition *requisition);
static gint gtk_accel_label_expose_event (GtkWidget *widget,
static void
gtk_accel_label_class_init (GtkAccelLabelClass *class)
{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkMiscClass *misc_class;
gtk_object_add_arg_type ("GtkAccelLabel::accel_widget", GTK_TYPE_WIDGET, GTK_ARG_READWRITE, ARG_ACCEL_WIDGET);
+ gobject_class->finalize = gtk_accel_label_finalize;
+
object_class->set_arg = gtk_accel_label_set_arg;
object_class->get_arg = gtk_accel_label_get_arg;
object_class->destroy = gtk_accel_label_destroy;
- object_class->finalize = gtk_accel_label_finalize;
widget_class->size_request = gtk_accel_label_size_request;
widget_class->expose_event = gtk_accel_label_expose_event;
}
static void
-gtk_accel_label_finalize (GtkObject *object)
+gtk_accel_label_finalize (GObject *object)
{
GtkAccelLabel *accel_label;
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_ACCEL_LABEL (object));
accel_label = GTK_ACCEL_LABEL (object);
g_free (accel_label->accel_string);
- GTK_OBJECT_CLASS (parent_class)->finalize (object);
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
guint
g_return_val_if_fail (accel_label != NULL, FALSE);
g_return_val_if_fail (GTK_IS_ACCEL_LABEL (accel_label), FALSE);
- class = GTK_ACCEL_LABEL_CLASS (GTK_OBJECT (accel_label)->klass);
+ class = GTK_ACCEL_LABEL_GET_CLASS (accel_label);
g_free (accel_label->accel_string);
accel_label->accel_string = NULL;
adjustment_signals[CHANGED] =
gtk_signal_new ("changed",
GTK_RUN_FIRST | GTK_RUN_NO_RECURSE,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkAdjustmentClass, changed),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
adjustment_signals[VALUE_CHANGED] =
gtk_signal_new ("value_changed",
GTK_RUN_FIRST | GTK_RUN_NO_RECURSE,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkAdjustmentClass, value_changed),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
gchar *p;
g_return_val_if_fail (arg_name != NULL, NULL);
- g_return_val_if_fail (GTK_FUNDAMENTAL_TYPE (base_class_type) == GTK_TYPE_OBJECT, NULL);
+ g_return_val_if_fail (GTK_TYPE_IS_OBJECT (base_class_type), NULL);
g_return_val_if_fail (class_n_args_offset != 0, NULL);
g_return_val_if_fail (arg_info_hash_table != NULL, NULL);
g_return_val_if_fail (arg_type > GTK_TYPE_NONE, NULL);
else
{
otype = object_type;
- while (!*info_p && GTK_FUNDAMENTAL_TYPE (otype) == GTK_TYPE_OBJECT)
+ while (!*info_p && GTK_TYPE_IS_OBJECT (otype))
{
GtkArgInfo info;
g_return_if_fail (arg != NULL);
fundamental_type = GTK_FUNDAMENTAL_TYPE (arg->type);
- if (fundamental_type > GTK_TYPE_FUNDAMENTAL_LAST)
- {
- fundamental_type = gtk_type_get_varargs_type (fundamental_type);
- if (!fundamental_type)
- fundamental_type = GTK_FUNDAMENTAL_TYPE (arg->type);
- }
if (fundamental_type == GTK_TYPE_STRING)
{
GTK_FUNDAMENTAL_TYPE (arg2->type), FALSE);
fundamental_type = GTK_FUNDAMENTAL_TYPE (arg1->type);
- if (fundamental_type > GTK_TYPE_FUNDAMENTAL_LAST)
- {
- fundamental_type = gtk_type_get_varargs_type (fundamental_type);
- if (!fundamental_type)
- fundamental_type = GTK_FUNDAMENTAL_TYPE (arg1->type);
- }
switch (fundamental_type)
{
case GTK_TYPE_BOXED:
equal = GTK_VALUE_BOXED (*arg1) == GTK_VALUE_BOXED (*arg2);
break;
- case GTK_TYPE_FOREIGN:
- equal = (GTK_VALUE_FOREIGN (*arg1).data == GTK_VALUE_FOREIGN (*arg2).data &&
- GTK_VALUE_FOREIGN (*arg1).notify == GTK_VALUE_FOREIGN (*arg2).notify);
- break;
- case GTK_TYPE_CALLBACK:
- equal = (GTK_VALUE_CALLBACK (*arg1).marshal == GTK_VALUE_CALLBACK (*arg2).marshal &&
- GTK_VALUE_CALLBACK (*arg1).data == GTK_VALUE_CALLBACK (*arg2).data &&
- GTK_VALUE_CALLBACK (*arg1).notify == GTK_VALUE_CALLBACK (*arg2).notify);
- break;
- case GTK_TYPE_ARGS:
- equal = (GTK_VALUE_ARGS (*arg1).n_args == GTK_VALUE_ARGS (*arg2).n_args &&
- GTK_VALUE_ARGS (*arg1).args == GTK_VALUE_ARGS (*arg2).args);
- break;
- case GTK_TYPE_OBJECT:
+ case G_TYPE_OBJECT:
equal = GTK_VALUE_OBJECT (*arg1) == GTK_VALUE_OBJECT (*arg2);
break;
case GTK_TYPE_POINTER:
equal = (GTK_VALUE_SIGNAL (*arg1).f == GTK_VALUE_SIGNAL (*arg2).f &&
GTK_VALUE_SIGNAL (*arg1).d == GTK_VALUE_SIGNAL (*arg2).d);
break;
- case GTK_TYPE_C_CALLBACK:
- equal = (GTK_VALUE_C_CALLBACK (*arg1).func == GTK_VALUE_C_CALLBACK (*arg2).func &&
- GTK_VALUE_C_CALLBACK (*arg1).func_data == GTK_VALUE_C_CALLBACK (*arg2).func_data);
- break;
default:
g_warning ("gtk_arg_values_equal() used with unknown type `%s'", gtk_type_name (arg1->type));
equal = FALSE;
g_return_if_fail (value_pointer != NULL);
fundamental_type = GTK_FUNDAMENTAL_TYPE (arg->type);
- if (fundamental_type > GTK_TYPE_FUNDAMENTAL_LAST)
- {
- fundamental_type = gtk_type_get_varargs_type (fundamental_type);
- if (!fundamental_type)
- fundamental_type = GTK_FUNDAMENTAL_TYPE (arg->type);
- }
switch (fundamental_type)
{
case GTK_TYPE_STRING:
case GTK_TYPE_POINTER:
case GTK_TYPE_BOXED:
- case GTK_TYPE_OBJECT:
+ case G_TYPE_OBJECT:
p_pointer = value_pointer;
*p_pointer = GTK_VALUE_POINTER (*arg);
break;
case GTK_TYPE_SIGNAL:
- case GTK_TYPE_ARGS:
- case GTK_TYPE_FOREIGN:
- case GTK_TYPE_CALLBACK:
- case GTK_TYPE_C_CALLBACK:
case GTK_TYPE_NONE:
case GTK_TYPE_INVALID:
/* it doesn't make much sense to retrive these values,
GtkType fundamental_type; \
\
fundamental_type = GTK_FUNDAMENTAL_TYPE (arg->type); \
- if (fundamental_type > GTK_TYPE_FUNDAMENTAL_LAST) \
- { \
- fundamental_type = gtk_type_get_varargs_type (fundamental_type); \
- if (!fundamental_type) \
- fundamental_type = GTK_FUNDAMENTAL_TYPE (arg->type); \
- } \
- \
+ \
error_msg = NULL; \
switch (fundamental_type) \
{ \
GTK_VALUE_SIGNAL (*arg).f = va_arg (var_args, GtkSignalFunc); \
GTK_VALUE_SIGNAL (*arg).d = va_arg (var_args, gpointer); \
break; \
- case GTK_TYPE_ARGS: \
- GTK_VALUE_ARGS (*arg).n_args = va_arg (var_args, gint); \
- GTK_VALUE_ARGS (*arg).args = va_arg (var_args, GtkArg*); \
- break; \
- case GTK_TYPE_FOREIGN: \
- GTK_VALUE_FOREIGN (*arg).data = va_arg (var_args, gpointer); \
- GTK_VALUE_FOREIGN (*arg).notify = va_arg (var_args, GtkDestroyNotify); \
- break; \
- case GTK_TYPE_CALLBACK: \
- GTK_VALUE_CALLBACK (*arg).marshal = va_arg (var_args, GtkCallbackMarshal); \
- GTK_VALUE_CALLBACK (*arg).data = va_arg (var_args, gpointer); \
- GTK_VALUE_CALLBACK (*arg).notify = va_arg (var_args, GtkDestroyNotify); \
- break; \
- case GTK_TYPE_C_CALLBACK: \
- GTK_VALUE_C_CALLBACK (*arg).func = va_arg (var_args, GtkFunction); \
- GTK_VALUE_C_CALLBACK (*arg).func_data = va_arg (var_args, gpointer); \
- break; \
\
/* we do some extra sanity checking when collecting objects, \
* i.e. if the object pointer is not NULL, we check whether we \
* actually got an object pointer within the desired class branch. \
*/ \
- case GTK_TYPE_OBJECT: \
+ case G_TYPE_OBJECT: \
GTK_VALUE_OBJECT (*arg) = va_arg (var_args, GtkObject*); \
if (GTK_VALUE_OBJECT (*arg) != NULL) \
{ \
register GtkObject *object = GTK_VALUE_OBJECT (*arg); \
\
- if (object->klass == NULL) \
+ if (((GTypeInstance*) object)->g_class == NULL) \
error_msg = g_strconcat ("invalid unclassed object pointer for argument type `", \
gtk_type_name (arg->type), \
"'", \
NULL); \
else if (!gtk_type_is_a (GTK_OBJECT_TYPE (object), arg->type)) \
error_msg = g_strconcat ("invalid object `", \
- gtk_type_name (GTK_OBJECT_TYPE (object)), \
+ gtk_type_name (G_OBJECT_TYPE (object)), \
"' for argument type `", \
gtk_type_name (arg->type), \
"'", \
if (binding_set)
return binding_set;
- binding_set = gtk_binding_set_new (gtk_type_name (class->type));
+ binding_set = gtk_binding_set_new (gtk_type_name (GTK_CLASS_TYPE (class)));
gtk_binding_set_add_path (binding_set,
GTK_PATH_CLASS,
- gtk_type_name (class->type),
+ gtk_type_name (GTK_CLASS_TYPE (class)),
GTK_PATH_PRIO_GTK);
g_dataset_id_set_data (class, key_id_class_binding_set, binding_set);
if (!button_type)
{
- static const GtkTypeInfo button_info =
+ static const GTypeInfo button_info =
{
- "GtkButton",
- sizeof (GtkButton),
sizeof (GtkButtonClass),
- (GtkClassInitFunc) gtk_button_class_init,
- (GtkObjectInitFunc) gtk_button_init,
- /* reserved_1 */ NULL,
- /* reserved_2 */ NULL,
- (GtkClassInitFunc) NULL,
+ NULL, /* base_init */
+ NULL, /* base_finalize */
+ (GClassInitFunc) gtk_button_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GtkButton),
+ 16, /* n_preallocs */
+ (GInstanceInitFunc) gtk_button_init,
};
- button_type = gtk_type_unique (GTK_TYPE_BIN, &button_info);
- gtk_type_set_chunk_alloc (button_type, 16);
+ button_type = g_type_register_static (GTK_TYPE_BIN, "GtkButton", &button_info);
}
return button_type;
button_signals[PRESSED] =
gtk_signal_new ("pressed",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkButtonClass, pressed),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
button_signals[RELEASED] =
gtk_signal_new ("released",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkButtonClass, released),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
button_signals[CLICKED] =
gtk_signal_new ("clicked",
GTK_RUN_FIRST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkButtonClass, clicked),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
button_signals[ENTER] =
gtk_signal_new ("enter",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkButtonClass, enter),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
button_signals[LEAVE] =
gtk_signal_new ("leave",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkButtonClass, leave),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
if (!calendar_type)
{
- static const GtkTypeInfo calendar_info =
+ static const GTypeInfo calendar_info =
{
- "GtkCalendar",
- sizeof (GtkCalendar),
sizeof (GtkCalendarClass),
- (GtkClassInitFunc) gtk_calendar_class_init,
- (GtkObjectInitFunc) gtk_calendar_init,
- (GtkArgSetFunc) NULL,
- (GtkArgGetFunc) NULL,
+ NULL, /* base_init */
+ NULL, /* base_finalize */
+ (GClassInitFunc) gtk_calendar_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GtkCalendar),
+ 16, /* n_preallocs */
+ (GInstanceInitFunc) gtk_calendar_init,
};
-
- calendar_type = gtk_type_unique (GTK_TYPE_WIDGET, &calendar_info);
+
+ calendar_type = g_type_register_static (GTK_TYPE_WIDGET, "GtkCalendar", &calendar_info);
}
return calendar_type;
gtk_calendar_signals[MONTH_CHANGED_SIGNAL] =
gtk_signal_new ("month_changed",
- GTK_RUN_FIRST, object_class->type,
+ GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCalendarClass, month_changed),
gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
gtk_calendar_signals[DAY_SELECTED_SIGNAL] =
gtk_signal_new ("day_selected",
- GTK_RUN_FIRST, object_class->type,
+ GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCalendarClass, day_selected),
gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
gtk_calendar_signals[DAY_SELECTED_DOUBLE_CLICK_SIGNAL] =
gtk_signal_new ("day_selected_double_click",
- GTK_RUN_FIRST, object_class->type,
+ GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCalendarClass, day_selected_double_click),
gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
gtk_calendar_signals[PREV_MONTH_SIGNAL] =
gtk_signal_new ("prev_month",
- GTK_RUN_FIRST, object_class->type,
+ GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCalendarClass, prev_month),
gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
gtk_calendar_signals[NEXT_MONTH_SIGNAL] =
gtk_signal_new ("next_month",
- GTK_RUN_FIRST, object_class->type,
+ GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCalendarClass, next_month),
gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
gtk_calendar_signals[PREV_YEAR_SIGNAL] =
gtk_signal_new ("prev_year",
- GTK_RUN_FIRST, object_class->type,
+ GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCalendarClass, prev_year),
gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
gtk_calendar_signals[NEXT_YEAR_SIGNAL] =
gtk_signal_new ("next_year",
- GTK_RUN_FIRST, object_class->type,
+ GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCalendarClass, next_year),
gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
#define INDICATOR_SIZE 10
#define INDICATOR_SPACING 2
-#define CHECK_BUTTON_CLASS(w) GTK_CHECK_BUTTON_CLASS (GTK_OBJECT (w)->klass)
-
static void gtk_check_button_class_init (GtkCheckButtonClass *klass);
static void gtk_check_button_init (GtkCheckButton *check_button);
if (toggle_button->draw_indicator)
{
- requisition->width += (CHECK_BUTTON_CLASS (widget)->indicator_size +
- CHECK_BUTTON_CLASS (widget)->indicator_spacing * 3 + 2);
+ requisition->width += (GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size +
+ GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_spacing * 3 + 2);
- temp = (CHECK_BUTTON_CLASS (widget)->indicator_size +
- CHECK_BUTTON_CLASS (widget)->indicator_spacing * 2);
+ temp = (GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size +
+ GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_spacing * 2);
requisition->height = MAX (requisition->height, temp) + 2;
}
}
if (GTK_BIN (button)->child && GTK_WIDGET_VISIBLE (GTK_BIN (button)->child))
{
child_allocation.x = (GTK_CONTAINER (widget)->border_width +
- CHECK_BUTTON_CLASS (widget)->indicator_size +
- CHECK_BUTTON_CLASS (widget)->indicator_spacing * 3 + 1 +
+ GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size +
+ GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_spacing * 3 + 1 +
widget->allocation.x);
child_allocation.y = GTK_CONTAINER (widget)->border_width + 1 +
widget->allocation.y;
child_allocation.width = MAX (1, allocation->width -
(GTK_CONTAINER (widget)->border_width +
- CHECK_BUTTON_CLASS (widget)->indicator_size +
- CHECK_BUTTON_CLASS (widget)->indicator_spacing * 3 + 1) -
+ GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size +
+ GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_spacing * 3 + 1) -
GTK_CONTAINER (widget)->border_width - 1);
child_allocation.height = MAX (1, allocation->height - (GTK_CONTAINER (widget)->border_width + 1) * 2);
g_return_if_fail (check_button != NULL);
g_return_if_fail (GTK_IS_CHECK_BUTTON (check_button));
- class = CHECK_BUTTON_CLASS (check_button);
+ class = GTK_CHECK_BUTTON_GET_CLASS (check_button);
if (class->draw_indicator)
(* class->draw_indicator) (check_button, area);
new_area.width, new_area.height);
}
- x = widget->allocation.x + CHECK_BUTTON_CLASS (widget)->indicator_spacing + GTK_CONTAINER (widget)->border_width;
- y = widget->allocation.y + (widget->allocation.height - CHECK_BUTTON_CLASS (widget)->indicator_size) / 2;
- width = CHECK_BUTTON_CLASS (widget)->indicator_size;
- height = CHECK_BUTTON_CLASS (widget)->indicator_size;
+ x = widget->allocation.x + GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_spacing + GTK_CONTAINER (widget)->border_width;
+ y = widget->allocation.y + (widget->allocation.height - GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size) / 2;
+ width = GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size;
+ height = GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size;
if (GTK_TOGGLE_BUTTON (widget)->active)
{
#include "gtksignal.h"
-#define CHECK_MENU_ITEM_CLASS(w) GTK_CHECK_MENU_ITEM_CLASS (GTK_OBJECT (w)->klass)
-
enum {
TOGGLED,
check_menu_item_signals[TOGGLED] =
gtk_signal_new ("toggled",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCheckMenuItemClass, toggled),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
{
g_return_if_fail (check_menu_item != NULL);
g_return_if_fail (GTK_IS_CHECK_MENU_ITEM (check_menu_item));
- g_return_if_fail (CHECK_MENU_ITEM_CLASS (check_menu_item) != NULL);
+ g_return_if_fail (GTK_CHECK_MENU_ITEM_GET_CLASS (check_menu_item) != NULL);
- if (CHECK_MENU_ITEM_CLASS (check_menu_item)->draw_indicator)
- (* CHECK_MENU_ITEM_CLASS (check_menu_item)->draw_indicator) (check_menu_item, area);
+ if (GTK_CHECK_MENU_ITEM_GET_CLASS (check_menu_item)->draw_indicator)
+ (* GTK_CHECK_MENU_ITEM_GET_CLASS (check_menu_item)->draw_indicator) (check_menu_item, area);
}
static void
gint x)
{
gint i, cx;
-
+
for (i = 0; i < clist->columns; i++)
if (clist->column[i].visible)
{
cx = clist->column[i].area.x + clist->hoffset;
-
+
if (x >= (cx - (COLUMN_INSET + CELL_SPACING)) &&
x <= (cx + clist->column[i].area.width + COLUMN_INSET))
return i;
}
-
+
/* no match */
return -1;
}
LIST_WIDTH (GtkCList * clist)
{
gint last_column;
-
+
for (last_column = clist->columns - 1;
last_column >= 0 && !clist->column[last_column].visible; last_column--);
-
+
if (last_column >= 0)
return (clist->column[last_column].area.x +
clist->column[last_column].area.width +
g_list_nth ((clist)->row_list, (row)))
-#define GTK_CLIST_CLASS_FW(_widget_) GTK_CLIST_CLASS (((GtkObject*) (_widget_))->klass)
-
/* redraw the list if it's not frozen */
#define CLIST_UNFROZEN(clist) (((GtkCList*) (clist))->freeze_count == 0)
#define CLIST_REFRESH(clist) G_STMT_START { \
if (CLIST_UNFROZEN (clist)) \
- GTK_CLIST_CLASS_FW (clist)->refresh ((GtkCList*) (clist)); \
+ GTK_CLIST_GET_CLASS (clist)->refresh ((GtkCList*) (clist)); \
} G_STMT_END
/* GtkObject Methods */
static void gtk_clist_destroy (GtkObject *object);
-static void gtk_clist_finalize (GtkObject *object);
+static void gtk_clist_finalize (GObject *object);
static void gtk_clist_set_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
GtkCListRow *dest_row,
gint dest_row_number,
GtkCListDragPos drag_pos);
-
+
/* Size Allocation / Requisition */
static void size_allocate_title_buttons (GtkCList *clist);
static void size_allocate_columns (GtkCList *clist,
gtk_clist_get_type (void)
{
static GtkType clist_type = 0;
-
+
if (!clist_type)
{
static const GtkTypeInfo clist_info =
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
-
+
clist_type = gtk_type_unique (GTK_TYPE_CONTAINER, &clist_info);
}
-
+
return clist_type;
}
static void
gtk_clist_class_init (GtkCListClass *klass)
{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkContainerClass *container_class;
GtkBindingSet *binding_set;
-
+
object_class = (GtkObjectClass *) klass;
widget_class = (GtkWidgetClass *) klass;
container_class = (GtkContainerClass *) klass;
-
+
parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
-
+
+ gobject_class->finalize = gtk_clist_finalize;
+
+ object_class->set_arg = gtk_clist_set_arg;
+ object_class->get_arg = gtk_clist_get_arg;
+ object_class->destroy = gtk_clist_destroy;
+
gtk_object_add_arg_type ("GtkCList::n_columns",
GTK_TYPE_UINT,
GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT_ONLY,
GTK_TYPE_SORT_TYPE,
GTK_ARG_READWRITE,
ARG_SORT_TYPE);
- object_class->set_arg = gtk_clist_set_arg;
- object_class->get_arg = gtk_clist_get_arg;
- object_class->destroy = gtk_clist_destroy;
- object_class->finalize = gtk_clist_finalize;
-
-
+
widget_class->set_scroll_adjustments_signal =
gtk_signal_new ("set_scroll_adjustments",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, set_scroll_adjustments),
gtk_marshal_NONE__POINTER_POINTER,
GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
-
+
clist_signals[SELECT_ROW] =
gtk_signal_new ("select_row",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, select_row),
gtk_marshal_NONE__INT_INT_POINTER,
GTK_TYPE_NONE, 3,
clist_signals[UNSELECT_ROW] =
gtk_signal_new ("unselect_row",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, unselect_row),
gtk_marshal_NONE__INT_INT_POINTER,
GTK_TYPE_NONE, 3, GTK_TYPE_INT,
clist_signals[ROW_MOVE] =
gtk_signal_new ("row_move",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, row_move),
gtk_marshal_NONE__INT_INT,
GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT);
clist_signals[CLICK_COLUMN] =
gtk_signal_new ("click_column",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, click_column),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1, GTK_TYPE_INT);
clist_signals[RESIZE_COLUMN] =
gtk_signal_new ("resize_column",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, resize_column),
gtk_marshal_NONE__INT_INT,
GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT);
-
+
clist_signals[TOGGLE_FOCUS_ROW] =
gtk_signal_new ("toggle_focus_row",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, toggle_focus_row),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
clist_signals[SELECT_ALL] =
gtk_signal_new ("select_all",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, select_all),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
clist_signals[UNSELECT_ALL] =
gtk_signal_new ("unselect_all",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, unselect_all),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
clist_signals[UNDO_SELECTION] =
gtk_signal_new ("undo_selection",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, undo_selection),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
clist_signals[START_SELECTION] =
gtk_signal_new ("start_selection",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, start_selection),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
clist_signals[END_SELECTION] =
gtk_signal_new ("end_selection",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, end_selection),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
clist_signals[TOGGLE_ADD_MODE] =
gtk_signal_new ("toggle_add_mode",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, toggle_add_mode),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
clist_signals[EXTEND_SELECTION] =
gtk_signal_new ("extend_selection",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, extend_selection),
gtk_marshal_NONE__ENUM_FLOAT_BOOL,
GTK_TYPE_NONE, 3,
clist_signals[SCROLL_VERTICAL] =
gtk_signal_new ("scroll_vertical",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, scroll_vertical),
gtk_marshal_NONE__ENUM_FLOAT,
GTK_TYPE_NONE, 2, GTK_TYPE_SCROLL_TYPE, GTK_TYPE_FLOAT);
clist_signals[SCROLL_HORIZONTAL] =
gtk_signal_new ("scroll_horizontal",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, scroll_horizontal),
gtk_marshal_NONE__ENUM_FLOAT,
GTK_TYPE_NONE, 2, GTK_TYPE_SCROLL_TYPE, GTK_TYPE_FLOAT);
clist_signals[ABORT_COLUMN_RESIZE] =
gtk_signal_new ("abort_column_resize",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, abort_column_resize),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
gtk_object_class_add_signals (object_class, clist_signals, LAST_SIGNAL);
-
+
widget_class->realize = gtk_clist_realize;
widget_class->unrealize = gtk_clist_unrealize;
widget_class->map = gtk_clist_map;
widget_class->drag_drop = gtk_clist_drag_drop;
widget_class->drag_data_get = gtk_clist_drag_data_get;
widget_class->drag_data_received = gtk_clist_drag_data_received;
-
+
/* container_class->add = NULL; use the default GtkContainerClass warning */
/* container_class->remove=NULL; use the default GtkContainerClass warning */
-
+
container_class->forall = gtk_clist_forall;
container_class->focus = gtk_clist_focus;
container_class->set_focus_child = gtk_clist_set_focus_child;
-
+
klass->set_scroll_adjustments = gtk_clist_set_scroll_adjustments;
klass->refresh = clist_refresh;
klass->select_row = real_select_row;
klass->abort_column_resize = abort_column_resize;
klass->set_cell_contents = set_cell_contents;
klass->cell_size_request = cell_size_request;
-
+
binding_set = gtk_binding_set_by_class (klass);
gtk_binding_entry_add_signal (binding_set, GDK_Up, 0,
"scroll_vertical", 2,
"scroll_vertical", 2,
GTK_TYPE_ENUM, GTK_SCROLL_JUMP,
GTK_TYPE_FLOAT, 1.0);
-
+
gtk_binding_entry_add_signal (binding_set, GDK_Up, GDK_SHIFT_MASK,
"extend_selection", 3,
GTK_TYPE_ENUM, GTK_SCROLL_STEP_BACKWARD,
"extend_selection", 3,
GTK_TYPE_ENUM, GTK_SCROLL_JUMP,
GTK_TYPE_FLOAT, 1.0, GTK_TYPE_BOOL, TRUE);
-
+
gtk_binding_entry_add_signal (binding_set, GDK_Left, 0,
"scroll_horizontal", 2,
GTK_TYPE_ENUM, GTK_SCROLL_STEP_BACKWARD,
"scroll_horizontal", 2,
GTK_TYPE_ENUM, GTK_SCROLL_JUMP,
GTK_TYPE_FLOAT, 1.0);
-
+
gtk_binding_entry_add_signal (binding_set, GDK_Escape, 0,
"undo_selection", 0);
gtk_binding_entry_add_signal (binding_set, GDK_Escape, 0,
guint arg_id)
{
GtkCList *clist;
-
+
clist = GTK_CLIST (object);
-
+
switch (arg_id)
{
case ARG_N_COLUMNS: /* construct-only arg, only set when !GTK_CONSTRUCTED */
guint arg_id)
{
GtkCList *clist;
-
+
clist = GTK_CLIST (object);
-
+
switch (arg_id)
{
guint i;
-
+
case ARG_N_COLUMNS:
GTK_VALUE_UINT (*arg) = clist->columns;
break;
gtk_clist_init (GtkCList *clist)
{
clist->flags = 0;
-
+
GTK_WIDGET_UNSET_FLAGS (clist, GTK_NO_WINDOW);
GTK_WIDGET_SET_FLAGS (clist, GTK_CAN_FOCUS);
GTK_CLIST_SET_FLAG (clist, CLIST_CHILD_HAS_FOCUS);
GTK_CLIST_SET_FLAG (clist, CLIST_DRAW_DRAG_LINE);
GTK_CLIST_SET_FLAG (clist, CLIST_USE_DRAG_ICONS);
-
+
clist->row_mem_chunk = NULL;
clist->cell_mem_chunk = NULL;
-
+
clist->freeze_count = 0;
-
+
clist->rows = 0;
clist->row_center_offset = 0;
clist->row_height = 0;
clist->row_list = NULL;
clist->row_list_end = NULL;
-
+
clist->columns = 0;
-
+
clist->title_window = NULL;
clist->column_title_area.x = 0;
clist->column_title_area.y = 0;
clist->column_title_area.width = 1;
clist->column_title_area.height = 1;
-
+
clist->clist_window = NULL;
clist->clist_window_width = 1;
clist->clist_window_height = 1;
-
+
clist->hoffset = 0;
clist->voffset = 0;
-
+
clist->shadow_type = GTK_SHADOW_IN;
clist->vadjustment = NULL;
clist->hadjustment = NULL;
-
+
clist->button_actions[0] = GTK_BUTTON_SELECTS | GTK_BUTTON_DRAGS;
clist->button_actions[1] = GTK_BUTTON_IGNORED;
clist->button_actions[2] = GTK_BUTTON_IGNORED;
clist->button_actions[3] = GTK_BUTTON_IGNORED;
clist->button_actions[4] = GTK_BUTTON_IGNORED;
-
+
clist->cursor_drag = NULL;
clist->xor_gc = NULL;
clist->fg_gc = NULL;
clist->bg_gc = NULL;
clist->x_drag = 0;
-
+
clist->selection_mode = GTK_SELECTION_SINGLE;
clist->selection = NULL;
clist->selection_end = NULL;
clist->undo_selection = NULL;
clist->undo_unselection = NULL;
-
+
clist->focus_row = -1;
clist->undo_anchor = -1;
-
+
clist->anchor = -1;
clist->anchor_state = GTK_STATE_SELECTED;
clist->drag_pos = -1;
clist->htimer = 0;
clist->vtimer = 0;
-
+
clist->click_cell.row = -1;
clist->click_cell.column = -1;
-
+
clist->compare = default_compare;
clist->sort_type = GTK_SORT_ASCENDING;
clist->sort_column = 0;
g_return_if_fail (GTK_IS_CLIST (clist));
g_return_if_fail (columns > 0);
g_return_if_fail (GTK_OBJECT_CONSTRUCTED (clist) == FALSE);
-
+
/* mark the object as constructed */
gtk_object_constructed (GTK_OBJECT (clist));
-
+
/* initalize memory chunks, if this has not been done by any
* possibly derived widget
*/
sizeof (GtkCListRow) *
CLIST_OPTIMUM_SIZE,
G_ALLOC_AND_FREE);
-
+
if (!clist->cell_mem_chunk)
clist->cell_mem_chunk = g_mem_chunk_new ("clist cell mem chunk",
sizeof (GtkCell) * columns,
sizeof (GtkCell) * columns *
CLIST_OPTIMUM_SIZE,
G_ALLOC_AND_FREE);
-
+
/* set number of columns, allocate memory */
clist->columns = columns;
clist->column = columns_new (clist);
-
+
/* there needs to be at least one column button
* because there is alot of code that will break if it
* isn't there*/
column_button_create (clist, 0);
-
+
if (titles)
{
guint i;
{
return gtk_clist_new_with_titles (columns, NULL);
}
-
+
GtkWidget*
gtk_clist_new_with_titles (gint columns,
gchar *titles[])
{
GtkWidget *widget;
-
+
widget = gtk_type_new (GTK_TYPE_CLIST);
gtk_clist_construct (GTK_CLIST (widget), columns, titles);
-
+
return widget;
}
GtkAdjustment *adjustment)
{
GtkAdjustment *old_adjustment;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
if (adjustment)
return;
old_adjustment = clist->hadjustment;
-
+
if (clist->hadjustment)
{
gtk_signal_disconnect_by_data (GTK_OBJECT (clist->hadjustment), clist);
gtk_object_unref (GTK_OBJECT (clist->hadjustment));
}
-
+
clist->hadjustment = adjustment;
-
+
if (clist->hadjustment)
{
gtk_object_ref (GTK_OBJECT (clist->hadjustment));
gtk_object_sink (GTK_OBJECT (clist->hadjustment));
-
+
gtk_signal_connect (GTK_OBJECT (clist->hadjustment), "changed",
(GtkSignalFunc) hadjustment_changed,
(gpointer) clist);
(GtkSignalFunc) hadjustment_value_changed,
(gpointer) clist);
}
-
+
if (!clist->hadjustment || !old_adjustment)
gtk_widget_queue_resize (GTK_WIDGET (clist));
}
{
g_return_val_if_fail (clist != NULL, NULL);
g_return_val_if_fail (GTK_IS_CLIST (clist), NULL);
-
+
return clist->hadjustment;
}
GtkAdjustment *adjustment)
{
GtkAdjustment *old_adjustment;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
if (adjustment)
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
-
+
if (clist->vadjustment == adjustment)
return;
old_adjustment = clist->vadjustment;
-
+
if (clist->vadjustment)
{
gtk_signal_disconnect_by_data (GTK_OBJECT (clist->vadjustment), clist);
gtk_object_unref (GTK_OBJECT (clist->vadjustment));
}
-
+
clist->vadjustment = adjustment;
-
+
if (clist->vadjustment)
{
gtk_object_ref (GTK_OBJECT (clist->vadjustment));
gtk_object_sink (GTK_OBJECT (clist->vadjustment));
-
+
gtk_signal_connect (GTK_OBJECT (clist->vadjustment), "changed",
(GtkSignalFunc) vadjustment_changed,
(gpointer) clist);
(GtkSignalFunc) vadjustment_value_changed,
(gpointer) clist);
}
-
+
if (!clist->vadjustment || !old_adjustment)
gtk_widget_queue_resize (GTK_WIDGET (clist));
}
{
g_return_val_if_fail (clist != NULL, NULL);
g_return_val_if_fail (GTK_IS_CLIST (clist), NULL);
-
+
return clist->vadjustment;
}
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
clist->shadow_type = type;
-
+
if (GTK_WIDGET_VISIBLE (clist))
gtk_widget_queue_resize (GTK_WIDGET (clist));
}
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (mode == clist->selection_mode)
return;
-
+
clist->selection_mode = mode;
clist->anchor = -1;
clist->anchor_state = GTK_STATE_SELECTED;
clist->drag_pos = -1;
clist->undo_anchor = clist->focus_row;
-
+
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
clist->undo_selection = NULL;
clist->undo_unselection = NULL;
-
+
switch (mode)
{
case GTK_SELECTION_MULTIPLE:
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
clist->freeze_count++;
}
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (clist->freeze_count)
{
clist->freeze_count--;
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (!GTK_CLIST_SHOW_TITLES(clist))
{
GTK_CLIST_SET_FLAG (clist, CLIST_SHOW_TITLES);
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (GTK_CLIST_SHOW_TITLES(clist))
{
GTK_CLIST_UNSET_FLAG (clist, CLIST_SHOW_TITLES);
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (column < 0 || column >= clist->columns)
return;
if (!clist->column[column].button || !clist->column[column].button_passive)
return;
-
+
clist->column[column].button_passive = FALSE;
-
+
gtk_signal_disconnect_by_func (GTK_OBJECT (clist->column[column].button),
(GtkSignalFunc) column_title_passive_func,
NULL);
-
+
GTK_WIDGET_SET_FLAGS (clist->column[column].button, GTK_CAN_FOCUS);
if (GTK_WIDGET_VISIBLE (clist))
gtk_widget_queue_draw (clist->column[column].button);
gint column)
{
GtkButton *button;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (column < 0 || column >= clist->columns)
return;
if (!clist->column[column].button || clist->column[column].button_passive)
return;
-
+
button = GTK_BUTTON (clist->column[column].button);
-
+
clist->column[column].button_passive = TRUE;
-
+
if (button->button_down)
gtk_button_released (button);
if (button->in_button)
gtk_button_leave (button);
-
+
gtk_signal_connect (GTK_OBJECT (clist->column[column].button), "event",
(GtkSignalFunc) column_title_passive_func, NULL);
-
+
GTK_WIDGET_UNSET_FLAGS (clist->column[column].button, GTK_CAN_FOCUS);
if (GTK_WIDGET_VISIBLE (clist))
gtk_widget_queue_draw (clist->column[column].button);
gtk_clist_column_titles_active (GtkCList *clist)
{
gint i;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (!GTK_CLIST_SHOW_TITLES(clist))
return;
-
+
for (i = 0; i < clist->columns; i++)
gtk_clist_column_title_active (clist, i);
}
gtk_clist_column_titles_passive (GtkCList *clist)
{
gint i;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (!GTK_CLIST_SHOW_TITLES(clist))
return;
-
+
for (i = 0; i < clist->columns; i++)
gtk_clist_column_title_passive (clist, i);
}
GtkWidget *old_widget;
GtkWidget *alignment = NULL;
GtkWidget *label;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (column < 0 || column >= clist->columns)
return;
-
+
/* if the column button doesn't currently exist,
* it has to be created first */
if (!clist->column[column].button)
column_button_create (clist, column);
new_button = 1;
}
-
+
column_title_new (clist, column, title);
-
+
/* remove and destroy the old widget */
old_widget = GTK_BIN (clist->column[column].button)->child;
if (old_widget)
gtk_container_remove (GTK_CONTAINER (clist->column[column].button), old_widget);
-
+
/* create new alignment based no column justification */
switch (clist->column[column].justification)
{
case GTK_JUSTIFY_LEFT:
alignment = gtk_alignment_new (0.0, 0.5, 0.0, 0.0);
break;
-
+
case GTK_JUSTIFY_RIGHT:
alignment = gtk_alignment_new (1.0, 0.5, 0.0, 0.0);
break;
-
+
case GTK_JUSTIFY_CENTER:
alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
break;
-
+
case GTK_JUSTIFY_FILL:
alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
break;
}
-
+
gtk_widget_push_composite_child ();
label = gtk_label_new (clist->column[column].title);
gtk_widget_pop_composite_child ();
gtk_container_add (GTK_CONTAINER (clist->column[column].button), alignment);
gtk_widget_show (label);
gtk_widget_show (alignment);
-
+
/* if this button didn't previously exist, then the
* column button positions have to be re-computed */
if (GTK_WIDGET_VISIBLE (clist) && new_button)
{
g_return_val_if_fail (clist != NULL, NULL);
g_return_val_if_fail (GTK_IS_CLIST (clist), NULL);
-
+
if (column < 0 || column >= clist->columns)
return NULL;
-
+
return clist->column[column].title;
}
{
gint new_button = 0;
GtkWidget *old_widget;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (column < 0 || column >= clist->columns)
return;
-
+
/* if the column button doesn't currently exist,
* it has to be created first */
if (!clist->column[column].button)
column_button_create (clist, column);
new_button = 1;
}
-
+
column_title_new (clist, column, NULL);
-
+
/* remove and destroy the old widget */
old_widget = GTK_BIN (clist->column[column].button)->child;
if (old_widget)
gtk_container_remove (GTK_CONTAINER (clist->column[column].button),
old_widget);
-
+
/* add and show the widget */
if (widget)
{
gtk_container_add (GTK_CONTAINER (clist->column[column].button), widget);
gtk_widget_show (widget);
}
-
+
/* if this button didn't previously exist, then the
* column button positions have to be re-computed */
if (GTK_WIDGET_VISIBLE (clist) && new_button)
{
g_return_val_if_fail (clist != NULL, NULL);
g_return_val_if_fail (GTK_IS_CLIST (clist), NULL);
-
+
if (column < 0 || column >= clist->columns)
return NULL;
-
+
if (clist->column[column].button)
return GTK_BUTTON (clist->column[column].button)->child;
-
+
return NULL;
}
GtkJustification justification)
{
GtkWidget *alignment;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (column < 0 || column >= clist->columns)
return;
-
+
clist->column[column].justification = justification;
-
+
/* change the alinment of the button title if it's not a
* custom widget */
if (clist->column[column].title)
{
alignment = GTK_BIN (clist->column[column].button)->child;
-
+
switch (clist->column[column].justification)
{
case GTK_JUSTIFY_LEFT:
gtk_alignment_set (GTK_ALIGNMENT (alignment), 0.0, 0.5, 0.0, 0.0);
break;
-
+
case GTK_JUSTIFY_RIGHT:
gtk_alignment_set (GTK_ALIGNMENT (alignment), 1.0, 0.5, 0.0, 0.0);
break;
-
+
case GTK_JUSTIFY_CENTER:
gtk_alignment_set (GTK_ALIGNMENT (alignment), 0.5, 0.5, 0.0, 0.0);
break;
-
+
case GTK_JUSTIFY_FILL:
gtk_alignment_set (GTK_ALIGNMENT (alignment), 0.5, 0.5, 0.0, 0.0);
break;
-
+
default:
break;
}
}
-
+
if (CLIST_UNFROZEN (clist))
draw_rows (clist, NULL);
}
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (column < 0 || column >= clist->columns)
return;
if (clist->column[column].visible == visible)
return;
-
+
/* don't hide last visible column */
if (!visible)
{
gint i;
gint vis_columns = 0;
-
+
for (i = 0, vis_columns = 0; i < clist->columns && vis_columns < 2; i++)
if (clist->column[i].visible)
vis_columns++;
-
+
if (vis_columns < 2)
return;
}
-
+
clist->column[column].visible = visible;
-
+
if (clist->column[column].button)
{
if (visible)
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (column < 0 || column >= clist->columns)
return;
if (clist->column[column].resizeable == resizeable)
return;
-
+
clist->column[column].resizeable = resizeable;
if (resizeable)
clist->column[column].auto_resize = FALSE;
-
+
if (GTK_WIDGET_VISIBLE (clist))
size_allocate_title_buttons (clist);
}
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (column < 0 || column >= clist->columns)
return;
if (clist->column[column].auto_resize == auto_resize)
return;
-
+
clist->column[column].auto_resize = auto_resize;
if (auto_resize)
{
if (!GTK_CLIST_AUTO_RESIZE_BLOCKED(clist))
{
gint width;
-
+
width = gtk_clist_optimal_column_width (clist, column);
gtk_clist_set_column_width (clist, column, width);
}
}
-
+
if (GTK_WIDGET_VISIBLE (clist))
size_allocate_title_buttons (clist);
}
{
gint i;
gint width;
-
+
g_return_val_if_fail (clist != NULL, 0);
g_return_val_if_fail (GTK_IS_CLIST (clist), 0);
-
+
gtk_clist_freeze (clist);
width = 0;
for (i = 0; i < clist->columns; i++)
{
gtk_clist_set_column_width (clist, i,
gtk_clist_optimal_column_width (clist, i));
-
+
width += clist->column[i].width;
}
-
+
gtk_clist_thaw (clist);
return width;
}
GtkRequisition requisition;
GList *list;
gint width;
-
+
g_return_val_if_fail (clist != NULL, 0);
g_return_val_if_fail (GTK_CLIST (clist), 0);
-
+
if (column < 0 || column > clist->columns)
return 0;
-
+
if (GTK_CLIST_SHOW_TITLES(clist) && clist->column[column].button)
width = (clist->column[column].button->requisition.width)
#if 0
- (CELL_SPACING + (2 * COLUMN_INSET)))
+ (CELL_SPACING + (2 * COLUMN_INSET)))
#endif
- ;
- else
- width = 0;
+ ;
+ else
+ width = 0;
- for (list = clist->row_list; list; list = list->next)
- {
- GTK_CLIST_CLASS_FW (clist)->cell_size_request
- (clist, GTK_CLIST_ROW (list), column, &requisition);
- width = MAX (width, requisition.width);
- }
+for (list = clist->row_list; list; list = list->next)
+{
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request
+ (clist, GTK_CLIST_ROW (list), column, &requisition);
+ width = MAX (width, requisition.width);
+}
- return width;
+return width;
}
void
gtk_clist_set_column_width (GtkCList *clist,
- gint column,
- gint width)
+ gint column,
+ gint width)
{
- g_return_if_fail (clist != NULL);
- g_return_if_fail (GTK_IS_CLIST (clist));
+g_return_if_fail (clist != NULL);
+g_return_if_fail (GTK_IS_CLIST (clist));
- if (column < 0 || column >= clist->columns)
- return;
-
- gtk_signal_emit (GTK_OBJECT (clist), clist_signals[RESIZE_COLUMN],
- column, width);
-}
+if (column < 0 || column >= clist->columns)
+ return;
+
+ gtk_signal_emit (GTK_OBJECT (clist), clist_signals[RESIZE_COLUMN],
+ column, width);
+ }
void
gtk_clist_set_column_min_width (GtkCList *clist,
- gint column,
- gint min_width)
+ gint column,
+ gint min_width)
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (column < 0 || column >= clist->columns)
return;
if (clist->column[column].min_width == min_width)
return;
-
+
if (clist->column[column].max_width >= 0 &&
clist->column[column].max_width < min_width)
clist->column[column].min_width = clist->column[column].max_width;
else
clist->column[column].min_width = min_width;
-
+
if (clist->column[column].area.width < clist->column[column].min_width)
gtk_clist_set_column_width (clist, column,clist->column[column].min_width);
}
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (column < 0 || column >= clist->columns)
return;
if (clist->column[column].max_width == max_width)
return;
-
+
if (clist->column[column].min_width >= 0 && max_width >= 0 &&
clist->column[column].min_width > max_width)
clist->column[column].max_width = clist->column[column].min_width;
{
/* resize column if needed for auto_resize */
GtkRequisition requisition;
-
+
if (!clist->column[column].auto_resize ||
GTK_CLIST_AUTO_RESIZE_BLOCKED(clist))
return;
-
+
if (clist_row)
- GTK_CLIST_CLASS_FW (clist)->cell_size_request (clist, clist_row,
- column, &requisition);
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
+ column, &requisition);
else
requisition.width = 0;
-
+
if (requisition.width > clist->column[column].width)
gtk_clist_set_column_width (clist, column, requisition.width);
else if (requisition.width < old_width &&
{
GList *list;
gint new_width = 0;
-
+
/* run a "gtk_clist_optimal_column_width" but break, if
* the column doesn't shrink */
if (GTK_CLIST_SHOW_TITLES(clist) && clist->column[column].button)
(CELL_SPACING + (2 * COLUMN_INSET)));
else
new_width = 0;
-
+
for (list = clist->row_list; list; list = list->next)
{
- GTK_CLIST_CLASS_FW (clist)->cell_size_request
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request
(clist, GTK_CLIST_ROW (list), column, &requisition);
new_width = MAX (new_width, requisition.width);
if (new_width == clist->column[column].width)
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (column < 0 || column >= clist->columns)
return;
if (clist->column[column].max_width >= 0 &&
width > clist->column[column].max_width)
width = clist->column[column].max_width;
-
+
clist->column[column].width = width;
clist->column[column].width_set = TRUE;
-
+
/* FIXME: this is quite expensive to do if the widget hasn't
* been size_allocated yet, and pointless. Should
* a flag be kept
*/
size_allocate_columns (clist, TRUE);
size_allocate_title_buttons (clist);
-
+
CLIST_REFRESH (clist);
}
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (!GTK_CLIST_IN_DRAG(clist))
return;
-
+
GTK_CLIST_UNSET_FLAG (clist, CLIST_IN_DRAG);
gtk_grab_remove (GTK_WIDGET (clist));
gdk_pointer_ungrab (GDK_CURRENT_TIME);
clist->drag_pos = -1;
-
+
if (clist->x_drag >= 0 && clist->x_drag <= clist->clist_window_width - 1)
draw_xor_line (clist);
-
+
if (GTK_CLIST_ADD_MODE(clist))
{
gdk_gc_set_line_attributes (clist->xor_gc, 1, GDK_LINE_ON_OFF_DASH, 0,0);
gint last_column;
gint last_button = 0;
gint i;
-
+
if (!GTK_WIDGET_REALIZED (clist))
return;
-
+
button_allocation.x = clist->hoffset;
button_allocation.y = 0;
button_allocation.width = 0;
button_allocation.height = clist->column_title_area.height;
-
+
/* find last visible column */
for (last_column = clist->columns - 1; last_column >= 0; last_column--)
if (clist->column[last_column].visible)
break;
-
+
for (i = 0; i < last_column; i++)
{
if (!clist->column[i].visible)
gdk_window_hide (clist->column[i].window);
continue;
}
-
+
button_allocation.width += (clist->column[i].area.width +
CELL_SPACING + 2 * COLUMN_INSET);
-
+
if (!clist->column[i + 1].button)
{
gdk_window_hide (clist->column[i].window);
continue;
}
-
+
gtk_widget_size_allocate (clist->column[last_button].button,
&button_allocation);
button_allocation.x += button_allocation.width;
button_allocation.width = 0;
-
+
if (clist->column[last_button].resizeable)
{
gdk_window_show (clist->column[last_button].window);
}
else
gdk_window_hide (clist->column[last_button].window);
-
+
last_button = i + 1;
}
-
+
button_allocation.width += (clist->column[last_column].area.width +
2 * (CELL_SPACING + COLUMN_INSET));
gtk_widget_size_allocate (clist->column[last_button].button,
&button_allocation);
-
+
if (clist->column[last_button].resizeable)
{
button_allocation.x += button_allocation.width;
-
+
gdk_window_show (clist->column[last_button].window);
gdk_window_move_resize (clist->column[last_button].window,
button_allocation.x - (DRAG_WIDTH / 2),
gint xoffset = CELL_SPACING + COLUMN_INSET;
gint last_column;
gint i;
-
+
/* find last visible column and calculate correct column width */
for (last_column = clist->columns - 1;
last_column >= 0 && !clist->column[last_column].visible; last_column--);
-
+
if (last_column < 0)
return;
-
+
for (i = 0; i <= last_column; i++)
{
if (!clist->column[i].visible)
clist->column[i].auto_resize && clist->column[i].button)
{
gint width;
-
+
width = (clist->column[i].button->requisition.width -
(CELL_SPACING + (2 * COLUMN_INSET)));
-
+
if (width > clist->column[i].width)
gtk_clist_set_column_width (clist, i, width);
}
-
+
clist->column[i].area.width = clist->column[i].width;
xoffset += clist->column[i].width + CELL_SPACING + (2* COLUMN_INSET);
}
xoffset += clist->column[i].button->requisition.width;
}
}
-
+
clist->column[last_column].area.width = clist->column[last_column].area.width
+ MAX (0, clist->clist_window_width + COLUMN_INSET - xoffset);
}
{
gint width = CELL_SPACING;
gint i;
-
+
for (i = clist->columns - 1; i >= 0; i--)
{
if (!clist->column[i].visible)
continue;
-
+
if (clist->column[i].width_set)
width += clist->column[i].width + CELL_SPACING + (2 * COLUMN_INSET);
else if (GTK_CLIST_SHOW_TITLES(clist) && clist->column[i].button)
width += clist->column[i].button->requisition.width;
}
-
+
return width;
}
gint cx;
gint dx;
gint last_column;
-
+
/* first translate the x position from widget->window
* to clist->clist_window */
cx = *x - xthickness;
-
+
for (last_column = clist->columns - 1;
last_column >= 0 && !clist->column[last_column].visible; last_column--);
-
+
/* calculate new column width making sure it doesn't end up
* less than the minimum width */
dx = (COLUMN_LEFT_XPIXEL (clist, column) + COLUMN_INSET +
(column < last_column) * CELL_SPACING);
width = cx - dx;
-
+
if (width < MAX (COLUMN_MIN_WIDTH, clist->column[column].min_width))
{
width = MAX (COLUMN_MIN_WIDTH, clist->column[column].min_width);
cx = dx + clist->column[column].max_width;
*x = cx + xthickness;
}
-
+
if (cx < 0 || cx > clist->clist_window_width)
*x = -1;
-
+
return width;
}
gint column)
{
GtkWidget *button;
-
+
gtk_widget_push_composite_child ();
button = clist->column[column].button = gtk_button_new ();
gtk_widget_pop_composite_child ();
-
+
if (GTK_WIDGET_REALIZED (clist) && clist->title_window)
gtk_widget_set_parent_window (clist->column[column].button,
clist->title_window);
gtk_widget_set_parent (button, GTK_WIDGET (clist));
-
+
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) column_button_clicked,
(gpointer) clist);
{
gint i;
GtkCList *clist;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CLIST (data));
-
+
clist = GTK_CLIST (data);
-
+
/* find the column who's button was pressed */
for (i = 0; i < clist->columns; i++)
if (clist->column[i].button == widget)
break;
-
+
gtk_signal_emit (GTK_OBJECT (clist), clist_signals[CLICK_COLUMN], i);
}
gint column)
{
GtkCListRow *clist_row;
-
+
g_return_val_if_fail (clist != NULL, -1);
g_return_val_if_fail (GTK_IS_CLIST (clist), -1);
-
+
if (row < 0 || row >= clist->rows)
return -1;
if (column < 0 || column >= clist->columns)
return -1;
-
+
clist_row = ROW_ELEMENT (clist, row)->data;
-
+
return clist_row->cell[column].type;
}
const gchar *text)
{
GtkCListRow *clist_row;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (row < 0 || row >= clist->rows)
return;
if (column < 0 || column >= clist->columns)
return;
-
+
clist_row = ROW_ELEMENT (clist, row)->data;
-
+
/* if text is null, then the cell is empty */
- GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ GTK_CLIST_GET_CLASS (clist)->set_cell_contents
(clist, clist_row, column, GTK_CELL_TEXT, text, 0, NULL, NULL);
-
+
/* redraw the list if it's not frozen */
if (CLIST_UNFROZEN (clist))
{
if (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
- GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+ GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
}
}
gchar **text)
{
GtkCListRow *clist_row;
-
+
g_return_val_if_fail (clist != NULL, 0);
g_return_val_if_fail (GTK_IS_CLIST (clist), 0);
-
+
if (row < 0 || row >= clist->rows)
return 0;
if (column < 0 || column >= clist->columns)
return 0;
-
+
clist_row = ROW_ELEMENT (clist, row)->data;
-
+
if (clist_row->cell[column].type != GTK_CELL_TEXT)
return 0;
-
+
if (text)
*text = GTK_CELL_TEXT (clist_row->cell[column])->text;
-
+
return 1;
}
GdkBitmap *mask)
{
GtkCListRow *clist_row;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (row < 0 || row >= clist->rows)
return;
if (column < 0 || column >= clist->columns)
return;
-
+
clist_row = ROW_ELEMENT (clist, row)->data;
gdk_pixmap_ref (pixmap);
if (mask) gdk_pixmap_ref (mask);
- GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ GTK_CLIST_GET_CLASS (clist)->set_cell_contents
(clist, clist_row, column, GTK_CELL_PIXMAP, NULL, 0, pixmap, mask);
-
+
/* redraw the list if it's not frozen */
if (CLIST_UNFROZEN (clist))
{
if (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
- GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+ GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
}
}
GdkBitmap **mask)
{
GtkCListRow *clist_row;
-
+
g_return_val_if_fail (clist != NULL, 0);
g_return_val_if_fail (GTK_IS_CLIST (clist), 0);
-
+
if (row < 0 || row >= clist->rows)
return 0;
if (column < 0 || column >= clist->columns)
return 0;
-
+
clist_row = ROW_ELEMENT (clist, row)->data;
-
+
if (clist_row->cell[column].type != GTK_CELL_PIXMAP)
return 0;
-
+
if (pixmap)
- {
- *pixmap = GTK_CELL_PIXMAP (clist_row->cell[column])->pixmap;
- /* mask can be NULL */
- *mask = GTK_CELL_PIXMAP (clist_row->cell[column])->mask;
- }
-
+ {
+ *pixmap = GTK_CELL_PIXMAP (clist_row->cell[column])->pixmap;
+ /* mask can be NULL */
+ *mask = GTK_CELL_PIXMAP (clist_row->cell[column])->mask;
+ }
+
return 1;
}
GdkBitmap *mask)
{
GtkCListRow *clist_row;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (row < 0 || row >= clist->rows)
return;
if (column < 0 || column >= clist->columns)
return;
-
+
clist_row = ROW_ELEMENT (clist, row)->data;
gdk_pixmap_ref (pixmap);
if (mask) gdk_pixmap_ref (mask);
- GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ GTK_CLIST_GET_CLASS (clist)->set_cell_contents
(clist, clist_row, column, GTK_CELL_PIXTEXT, text, spacing, pixmap, mask);
-
+
/* redraw the list if it's not frozen */
if (CLIST_UNFROZEN (clist))
{
if (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
- GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+ GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
}
}
GdkBitmap **mask)
{
GtkCListRow *clist_row;
-
+
g_return_val_if_fail (clist != NULL, 0);
g_return_val_if_fail (GTK_IS_CLIST (clist), 0);
-
+
if (row < 0 || row >= clist->rows)
return 0;
if (column < 0 || column >= clist->columns)
return 0;
-
+
clist_row = ROW_ELEMENT (clist, row)->data;
-
+
if (clist_row->cell[column].type != GTK_CELL_PIXTEXT)
return 0;
-
+
if (text)
*text = GTK_CELL_PIXTEXT (clist_row->cell[column])->text;
if (spacing)
*spacing = GTK_CELL_PIXTEXT (clist_row->cell[column])->spacing;
if (pixmap)
*pixmap = GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap;
-
+
/* mask can be NULL */
*mask = GTK_CELL_PIXTEXT (clist_row->cell[column])->mask;
-
+
return 1;
}
{
GtkRequisition requisition = { 0 };
GtkCListRow *clist_row;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (row < 0 || row >= clist->rows)
return;
if (column < 0 || column >= clist->columns)
return;
-
+
clist_row = ROW_ELEMENT (clist, row)->data;
-
+
if (clist->column[column].auto_resize &&
!GTK_CLIST_AUTO_RESIZE_BLOCKED(clist))
- GTK_CLIST_CLASS_FW (clist)->cell_size_request (clist, clist_row,
- column, &requisition);
-
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
+ column, &requisition);
+
clist_row->cell[column].vertical = vertical;
clist_row->cell[column].horizontal = horizontal;
-
+
column_auto_resize (clist, clist_row, column, requisition.width);
-
+
if (CLIST_UNFROZEN (clist) && gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
- GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+ GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
}
/* PRIVATE CELL FUNCTIONS
GdkBitmap *mask)
{
GtkRequisition requisition;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
g_return_if_fail (clist_row != NULL);
-
+
if (clist->column[column].auto_resize &&
!GTK_CLIST_AUTO_RESIZE_BLOCKED(clist))
- GTK_CLIST_CLASS_FW (clist)->cell_size_request (clist, clist_row,
- column, &requisition);
-
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
+ column, &requisition);
+
switch (clist_row->cell[column].type)
{
case GTK_CELL_EMPTY:
default:
break;
}
-
+
clist_row->cell[column].type = GTK_CELL_EMPTY;
-
+
switch (type)
{
case GTK_CELL_TEXT:
default:
break;
}
-
+
if (clist->column[column].auto_resize &&
!GTK_CLIST_AUTO_RESIZE_BLOCKED(clist))
column_auto_resize (clist, clist_row, column, requisition.width);
GtkStyle *style;
gint width;
gint height;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
g_return_if_fail (requisition != NULL);
-
+
get_cell_style (clist, clist_row, GTK_STATE_NORMAL, column, &style,
NULL, NULL);
-
+
switch (clist_row->cell[column].type)
{
case GTK_CELL_TEXT:
GTK_CELL_PIXTEXT (clist_row->cell[column])->spacing +
gdk_string_width (style->font,
GTK_CELL_TEXT (clist_row->cell[column])->text);
-
+
requisition->height = MAX (style->font->ascent + style->font->descent,
height);
break;
requisition->height = 0;
break;
}
-
+
requisition->width += clist_row->cell[column].horizontal;
requisition->height += clist_row->cell[column].vertical;
}
g_return_val_if_fail (clist != NULL, -1);
g_return_val_if_fail (GTK_IS_CLIST (clist), -1);
g_return_val_if_fail (text != NULL, -1);
-
- return GTK_CLIST_CLASS_FW (clist)->insert_row (clist, 0, text);
+
+ return GTK_CLIST_GET_CLASS (clist)->insert_row (clist, 0, text);
}
gint
g_return_val_if_fail (clist != NULL, -1);
g_return_val_if_fail (GTK_IS_CLIST (clist), -1);
g_return_val_if_fail (text != NULL, -1);
-
- return GTK_CLIST_CLASS_FW (clist)->insert_row (clist, clist->rows, text);
+
+ return GTK_CLIST_GET_CLASS (clist)->insert_row (clist, clist->rows, text);
}
gint
g_return_val_if_fail (clist != NULL, -1);
g_return_val_if_fail (GTK_IS_CLIST (clist), -1);
g_return_val_if_fail (text != NULL, -1);
-
+
if (row < 0 || row > clist->rows)
row = clist->rows;
-
- return GTK_CLIST_CLASS_FW (clist)->insert_row (clist, row, text);
+
+ return GTK_CLIST_GET_CLASS (clist)->insert_row (clist, row, text);
}
void
gtk_clist_remove (GtkCList *clist,
gint row)
{
- GTK_CLIST_CLASS_FW (clist)->remove_row (clist, row);
+ GTK_CLIST_GET_CLASS (clist)->remove_row (clist, row);
}
void
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
- GTK_CLIST_CLASS_FW (clist)->clear (clist);
+ GTK_CLIST_GET_CLASS (clist)->clear (clist);
}
/* PRIVATE INSERT/REMOVE ROW FUNCTIONS
{
gint i;
GtkCListRow *clist_row;
-
+
g_return_val_if_fail (clist != NULL, -1);
g_return_val_if_fail (GTK_IS_CLIST (clist), -1);
g_return_val_if_fail (text != NULL, -1);
-
+
/* return if out of bounds */
if (row < 0 || row > clist->rows)
return -1;
-
+
/* create the row */
clist_row = row_new (clist);
-
+
/* set the text in the row's columns */
for (i = 0; i < clist->columns; i++)
if (text[i])
- GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ GTK_CLIST_GET_CLASS (clist)->set_cell_contents
(clist, clist_row, i, GTK_CELL_TEXT, text[i], 0, NULL ,NULL);
-
+
if (!clist->rows)
{
clist->row_list = g_list_append (clist->row_list, clist_row);
clist_row))->next;
else
clist->row_list = g_list_insert (clist->row_list, clist_row, row);
-
+
}
clist->rows++;
-
+
if (row < ROW_FROM_YPIXEL (clist, 0))
clist->voffset -= (clist->row_height + CELL_SPACING);
-
+
/* syncronize the selection list */
sync_selection (clist, row, SYNC_INSERT);
-
+
if (clist->rows == 1)
{
clist->focus_row = 0;
if (clist->selection_mode == GTK_SELECTION_BROWSE)
gtk_clist_select_row (clist, 0, -1);
}
-
+
/* redraw the list if it isn't frozen */
if (CLIST_UNFROZEN (clist))
{
adjust_adjustments (clist, FALSE);
-
+
if (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
draw_rows (clist, NULL);
}
-
+
return row;
}
gint was_visible, was_selected;
GList *list;
GtkCListRow *clist_row;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
/* return if out of bounds */
if (row < 0 || row > (clist->rows - 1))
return;
-
+
was_visible = (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE);
was_selected = 0;
-
+
/* get the row we're going to delete */
list = ROW_ELEMENT (clist, row);
g_assert (list != NULL);
clist_row = list->data;
-
+
/* if we're removing a selected row, we have to make sure
* it's properly unselected, and then sync up the clist->selected
* list to reflect the deincrimented indexies of rows after the
if (clist_row->state == GTK_STATE_SELECTED)
gtk_signal_emit (GTK_OBJECT (clist), clist_signals[UNSELECT_ROW],
row, -1, NULL);
-
+
/* reset the row end pointer if we're removing at the end of the list */
clist->rows--;
if (clist->row_list == list)
if (clist->row_list_end == list)
clist->row_list_end = g_list_previous (list);
g_list_remove (list, clist_row);
-
+
/*if (clist->focus_row >=0 &&
- (row <= clist->focus_row || clist->focus_row >= clist->rows))
- clist->focus_row--;*/
-
+ (row <= clist->focus_row || clist->focus_row >= clist->rows))
+ clist->focus_row--;*/
+
if (row < ROW_FROM_YPIXEL (clist, 0))
clist->voffset += clist->row_height + CELL_SPACING;
-
+
sync_selection (clist, row, SYNC_REMOVE);
-
+
if (clist->selection_mode == GTK_SELECTION_BROWSE && !clist->selection &&
clist->focus_row >= 0)
gtk_signal_emit (GTK_OBJECT (clist), clist_signals[SELECT_ROW],
clist->focus_row, -1, NULL);
-
+
/* toast the row */
row_delete (clist, clist_row);
-
+
/* redraw the row if it isn't frozen */
if (CLIST_UNFROZEN (clist))
{
adjust_adjustments (clist, FALSE);
-
+
if (was_visible)
draw_rows (clist, NULL);
}
GList *list;
GList *free_list;
gint i;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
/* free up the selection list */
g_list_free (clist->selection);
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
-
+
clist->selection = NULL;
clist->selection_end = NULL;
clist->undo_selection = NULL;
clist->undo_anchor = -1;
clist->anchor_state = GTK_STATE_SELECTED;
clist->drag_pos = -1;
-
+
/* remove all the rows */
GTK_CLIST_SET_FLAG (clist, CLIST_AUTO_RESIZE_BLOCKED);
free_list = clist->row_list;
GList *list;
gint first, last;
gint d;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (GTK_CLIST_AUTO_SORT(clist))
return;
-
+
if (source_row < 0 || source_row >= clist->rows ||
dest_row < 0 || dest_row >= clist->rows ||
source_row == dest_row)
return;
-
+
gtk_clist_freeze (clist);
-
+
/* unlink source row */
clist_row = ROW_ELEMENT (clist, source_row)->data;
if (source_row == clist->rows - 1)
clist->row_list_end = clist->row_list_end->prev;
clist->row_list = g_list_remove (clist->row_list, clist_row);
clist->rows--;
-
+
/* relink source row */
clist->row_list = g_list_insert (clist->row_list, clist_row, dest_row);
if (dest_row == clist->rows)
clist->row_list_end = clist->row_list_end->next;
clist->rows++;
-
+
/* sync selection */
if (source_row > dest_row)
{
last = dest_row;
d = -1;
}
-
+
for (list = clist->selection; list; list = list->next)
{
if (list->data == GINT_TO_POINTER (source_row))
clist->focus_row = dest_row;
else if (clist->focus_row > first)
clist->focus_row += d;
-
+
gtk_clist_thaw (clist);
}
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (row < -1 || row >= clist->rows)
return;
if (column < -1 || column >= clist->columns)
return;
-
+
row_align = CLAMP (row_align, 0, 1);
col_align = CLAMP (col_align, 0, 1);
-
+
/* adjust horizontal scrollbar */
if (clist->hadjustment && column >= 0)
{
gint x;
-
+
x = (COLUMN_LEFT (clist, column) - CELL_SPACING - COLUMN_INSET -
(col_align * (clist->clist_window_width - 2 * COLUMN_INSET -
CELL_SPACING - clist->column[column].area.width)));
else
gtk_adjustment_set_value (clist->hadjustment, x);
}
-
+
/* adjust vertical scrollbar */
if (clist->vadjustment && row >= 0)
move_vertical (clist, row, row_align);
guint height)
{
GtkWidget *widget;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
widget = GTK_WIDGET (clist);
-
+
if (height > 0)
{
clist->row_height = height;
GTK_CLIST_UNSET_FLAG (clist, CLIST_ROW_HEIGHT_SET);
clist->row_height = 0;
}
-
+
if (GTK_WIDGET_REALIZED (clist))
{
if (!GTK_CLIST_ROW_HEIGHT_SET(clist))
widget->style->font->ascent -
widget->style->font->descent - 1) / 2;
}
-
+
CLIST_REFRESH (clist);
}
GtkDestroyNotify destroy)
{
GtkCListRow *clist_row;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (row < 0 || row > (clist->rows - 1))
return;
-
+
clist_row = ROW_ELEMENT (clist, row)->data;
-
+
if (clist_row->destroy)
clist_row->destroy (clist_row->data);
gint row)
{
GtkCListRow *clist_row;
-
+
g_return_val_if_fail (clist != NULL, NULL);
g_return_val_if_fail (GTK_IS_CLIST (clist), NULL);
-
+
if (row < 0 || row > (clist->rows - 1))
return NULL;
-
+
clist_row = ROW_ELEMENT (clist, row)->data;
return clist_row->data;
}
{
GList *list;
gint n;
-
+
g_return_val_if_fail (clist != NULL, -1);
g_return_val_if_fail (GTK_IS_CLIST (clist), -1);
-
+
for (n = 0, list = clist->row_list; list; n++, list = list->next)
if (GTK_CLIST_ROW (list)->data == data)
return n;
-
+
return -1;
}
gint row2)
{
gint first, last;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
g_return_if_fail (row1 != row2);
-
+
if (GTK_CLIST_AUTO_SORT(clist))
return;
-
+
gtk_clist_freeze (clist);
-
+
first = MIN (row1, row2);
last = MAX (row1, row2);
-
+
gtk_clist_row_move (clist, last, first);
gtk_clist_row_move (clist, first + 1, last);
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (GTK_CLIST_AUTO_SORT(clist))
return;
-
+
if (source_row < 0 || source_row >= clist->rows ||
dest_row < 0 || dest_row >= clist->rows ||
source_row == dest_row)
return;
-
+
gtk_signal_emit (GTK_OBJECT (clist), clist_signals[ROW_MOVE],
source_row, dest_row);
}
gint row)
{
gint top;
-
+
g_return_val_if_fail (clist != NULL, 0);
g_return_val_if_fail (GTK_IS_CLIST (clist), 0);
-
+
if (row < 0 || row >= clist->rows)
return GTK_VISIBILITY_NONE;
-
+
if (clist->row_height == 0)
return GTK_VISIBILITY_NONE;
-
+
if (row < ROW_FROM_YPIXEL (clist, 0))
return GTK_VISIBILITY_NONE;
-
+
if (row > ROW_FROM_YPIXEL (clist, clist->clist_window_height))
return GTK_VISIBILITY_NONE;
-
+
top = ROW_TOP_YPIXEL (clist, row);
-
+
if ((top < 0)
|| ((top + clist->row_height) >= clist->clist_window_height))
return GTK_VISIBILITY_PARTIAL;
-
+
return GTK_VISIBILITY_FULL;
}
GdkColor *color)
{
GtkCListRow *clist_row;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (row < 0 || row >= clist->rows)
return;
-
+
clist_row = ROW_ELEMENT (clist, row)->data;
-
+
if (color)
{
clist_row->foreground = *color;
}
else
clist_row->fg_set = FALSE;
-
+
if (CLIST_UNFROZEN (clist) && gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
- GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+ GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
}
void
GdkColor *color)
{
GtkCListRow *clist_row;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (row < 0 || row >= clist->rows)
return;
-
+
clist_row = ROW_ELEMENT (clist, row)->data;
-
+
if (color)
{
clist_row->background = *color;
}
else
clist_row->bg_set = FALSE;
-
+
if (CLIST_UNFROZEN (clist)
&& (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE))
- GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+ GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
}
/* PUBLIC ROW/CELL STYLE FUNCTIONS
{
GtkRequisition requisition = { 0 };
GtkCListRow *clist_row;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (row < 0 || row >= clist->rows)
return;
if (column < 0 || column >= clist->columns)
return;
-
+
clist_row = ROW_ELEMENT (clist, row)->data;
-
+
if (clist_row->cell[column].style == style)
return;
-
+
if (clist->column[column].auto_resize &&
!GTK_CLIST_AUTO_RESIZE_BLOCKED(clist))
- GTK_CLIST_CLASS_FW (clist)->cell_size_request (clist, clist_row,
- column, &requisition);
-
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
+ column, &requisition);
+
if (clist_row->cell[column].style)
{
if (GTK_WIDGET_REALIZED (clist))
gtk_style_detach (clist_row->cell[column].style);
gtk_style_unref (clist_row->cell[column].style);
}
-
+
clist_row->cell[column].style = style;
-
+
if (clist_row->cell[column].style)
{
gtk_style_ref (clist_row->cell[column].style);
gtk_style_attach (clist_row->cell[column].style,
clist->clist_window);
}
-
+
column_auto_resize (clist, clist_row, column, requisition.width);
-
+
/* redraw the list if it's not frozen */
if (CLIST_UNFROZEN (clist))
{
if (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
- GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+ GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
}
}
gint column)
{
GtkCListRow *clist_row;
-
+
g_return_val_if_fail (clist != NULL, NULL);
g_return_val_if_fail (GTK_IS_CLIST (clist), NULL);
-
+
if (row < 0 || row >= clist->rows || column < 0 || column >= clist->columns)
return NULL;
-
+
clist_row = ROW_ELEMENT (clist, row)->data;
-
+
return clist_row->cell[column].style;
}
GtkCListRow *clist_row;
gint *old_width;
gint i;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (row < 0 || row >= clist->rows)
return;
-
+
clist_row = ROW_ELEMENT (clist, row)->data;
-
+
if (clist_row->style == style)
return;
-
+
old_width = g_new (gint, clist->columns);
-
+
if (!GTK_CLIST_AUTO_RESIZE_BLOCKED(clist))
{
for (i = 0; i < clist->columns; i++)
if (clist->column[i].auto_resize)
{
- GTK_CLIST_CLASS_FW (clist)->cell_size_request (clist, clist_row,
- i, &requisition);
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
+ i, &requisition);
old_width[i] = requisition.width;
}
}
-
+
if (clist_row->style)
{
if (GTK_WIDGET_REALIZED (clist))
gtk_style_detach (clist_row->style);
gtk_style_unref (clist_row->style);
}
-
+
clist_row->style = style;
-
+
if (clist_row->style)
{
gtk_style_ref (clist_row->style);
clist_row->style = gtk_style_attach (clist_row->style,
clist->clist_window);
}
-
+
if (GTK_CLIST_AUTO_RESIZE_BLOCKED(clist))
for (i = 0; i < clist->columns; i++)
column_auto_resize (clist, clist_row, i, old_width[i]);
-
+
g_free (old_width);
-
+
/* redraw the list if it's not frozen */
if (CLIST_UNFROZEN (clist))
{
if (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
- GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+ GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
}
}
gint row)
{
GtkCListRow *clist_row;
-
+
g_return_val_if_fail (clist != NULL, NULL);
g_return_val_if_fail (GTK_IS_CLIST (clist), NULL);
-
+
if (row < 0 || row >= clist->rows)
return NULL;
-
+
clist_row = ROW_ELEMENT (clist, row)->data;
-
+
return clist_row->style;
}
gboolean selectable)
{
GtkCListRow *clist_row;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (row < 0 || row >= clist->rows)
return;
-
+
clist_row = ROW_ELEMENT (clist, row)->data;
-
+
if (selectable == clist_row->selectable)
return;
-
+
clist_row->selectable = selectable;
-
+
if (!selectable && clist_row->state == GTK_STATE_SELECTED)
{
if (clist->anchor >= 0 &&
{
clist->drag_button = 0;
remove_grab (clist);
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
}
gtk_signal_emit (GTK_OBJECT (clist), clist_signals[UNSELECT_ROW],
row, -1, NULL);
{
g_return_val_if_fail (clist != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CLIST (clist), FALSE);
-
+
if (row < 0 || row >= clist->rows)
return FALSE;
-
+
return GTK_CLIST_ROW (ROW_ELEMENT (clist, row))->selectable;
}
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (row < 0 || row >= clist->rows)
return;
if (column < -1 || column >= clist->columns)
return;
-
+
gtk_signal_emit (GTK_OBJECT (clist), clist_signals[SELECT_ROW],
row, column, NULL);
}
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (row < 0 || row >= clist->rows)
return;
if (column < -1 || column >= clist->columns)
return;
-
+
gtk_signal_emit (GTK_OBJECT (clist), clist_signals[UNSELECT_ROW],
row, column, NULL);
}
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
- GTK_CLIST_CLASS_FW (clist)->select_all (clist);
+
+ GTK_CLIST_GET_CLASS (clist)->select_all (clist);
}
void
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
- GTK_CLIST_CLASS_FW (clist)->unselect_all (clist);
+
+ GTK_CLIST_GET_CLASS (clist)->unselect_all (clist);
}
void
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (clist->selection_mode == GTK_SELECTION_EXTENDED &&
(clist->undo_selection || clist->undo_unselection))
gtk_signal_emit (GTK_OBJECT (clist), clist_signals[UNDO_SELECTION]);
GdkEvent *event)
{
GtkCListRow *clist_row;
-
+
switch (clist->selection_mode)
{
case GTK_SELECTION_EXTENDED:
case GTK_SELECTION_MULTIPLE:
case GTK_SELECTION_SINGLE:
clist_row = ROW_ELEMENT (clist, row)->data;
-
+
if (!clist_row)
return;
-
+
if (clist_row->state == GTK_STATE_SELECTED)
{
gtk_signal_emit (GTK_OBJECT (clist), clist_signals[UNSELECT_ROW],
gint row)
{
GList *work;
-
+
work = ROW_ELEMENT (clist, row);
-
+
if (!work || !GTK_CLIST_ROW (work)->selectable)
return;
if (CLIST_UNFROZEN (clist) &&
gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
- GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row,
- GTK_CLIST_ROW (work));
+ GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row,
+ GTK_CLIST_ROW (work));
}
static void
{
g_return_if_fail (clist != 0);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist)) ||
clist->focus_row < 0 || clist->focus_row >= clist->rows)
return;
-
+
switch (clist->selection_mode)
{
case GTK_SELECTION_SINGLE:
g_list_free (clist->undo_unselection);
clist->undo_selection = NULL;
clist->undo_unselection = NULL;
-
+
clist->anchor = clist->focus_row;
clist->drag_pos = clist->focus_row;
clist->undo_anchor = clist->focus_row;
if (GTK_CLIST_ADD_MODE(clist))
fake_toggle_row (clist, clist->focus_row);
else
- GTK_CLIST_CLASS_FW (clist)->fake_unselect_all (clist,clist->focus_row);
-
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->fake_unselect_all (clist,clist->focus_row);
+
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
break;
default:
break;
if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist)) ||
clist->selection_mode != GTK_SELECTION_EXTENDED)
return;
-
+
gtk_clist_draw_focus (GTK_WIDGET (clist));
if (!GTK_CLIST_ADD_MODE(clist))
{
GList *list;
gint sel_row;
gboolean row_selected;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (row < 0 || row > (clist->rows - 1))
return;
-
+
switch (clist->selection_mode)
{
case GTK_SELECTION_SINGLE:
case GTK_SELECTION_BROWSE:
-
+
row_selected = FALSE;
list = clist->selection;
-
+
while (list)
{
sel_row = GPOINTER_TO_INT (list->data);
list = list->next;
-
+
if (row == sel_row)
row_selected = TRUE;
else
gtk_signal_emit (GTK_OBJECT (clist), clist_signals[UNSELECT_ROW],
sel_row, column, event);
}
-
+
if (row_selected)
return;
default:
break;
}
-
+
clist_row = ROW_ELEMENT (clist, row)->data;
-
+
if (clist_row->state != GTK_STATE_NORMAL || !clist_row->selectable)
return;
-
+
clist_row->state = GTK_STATE_SELECTED;
if (!clist->selection)
{
if (CLIST_UNFROZEN (clist)
&& (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE))
- GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+ GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
}
static void
GdkEvent *event)
{
GtkCListRow *clist_row;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (row < 0 || row > (clist->rows - 1))
return;
-
+
clist_row = ROW_ELEMENT (clist, row)->data;
-
+
if (clist_row->state == GTK_STATE_SELECTED)
{
clist_row->state = GTK_STATE_NORMAL;
-
+
if (clist->selection_end &&
clist->selection_end->data == GINT_TO_POINTER (row))
clist->selection_end = clist->selection_end->prev;
-
+
clist->selection = g_list_remove (clist->selection,
GINT_TO_POINTER (row));
if (CLIST_UNFROZEN (clist)
&& (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE))
- GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+ GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
}
}
{
GList *list;
gint i;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
return;
-
+
switch (clist->selection_mode)
{
case GTK_SELECTION_SINGLE:
case GTK_SELECTION_BROWSE:
return;
-
+
case GTK_SELECTION_EXTENDED:
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
clist->undo_selection = NULL;
clist->undo_unselection = NULL;
-
+
if (clist->rows &&
((GtkCListRow *) (clist->row_list->data))->state !=
GTK_STATE_SELECTED)
fake_toggle_row (clist, 0);
-
+
clist->anchor_state = GTK_STATE_SELECTED;
clist->anchor = 0;
clist->drag_pos = 0;
clist->undo_anchor = clist->focus_row;
update_extended_selection (clist, clist->rows);
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
return;
-
+
case GTK_SELECTION_MULTIPLE:
for (i = 0, list = clist->row_list; list; i++, list = list->next)
{
{
GList *list;
gint i;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
return;
-
+
switch (clist->selection_mode)
{
case GTK_SELECTION_BROWSE:
g_list_free (clist->undo_unselection);
clist->undo_selection = NULL;
clist->undo_unselection = NULL;
-
+
clist->anchor = -1;
clist->drag_pos = -1;
clist->undo_anchor = clist->focus_row;
default:
break;
}
-
+
list = clist->selection;
while (list)
{
GList *list;
GList *work;
gint i;
-
+
if (row >= 0 && (work = ROW_ELEMENT (clist, row)))
{
if (GTK_CLIST_ROW (work)->state == GTK_STATE_NORMAL &&
if (CLIST_UNFROZEN (clist) &&
gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
- GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row,
- GTK_CLIST_ROW (work));
+ GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row,
+ GTK_CLIST_ROW (work));
}
}
-
+
clist->undo_selection = clist->selection;
clist->selection = NULL;
clist->selection_end = NULL;
-
+
for (list = clist->undo_selection; list; list = list->next)
{
if ((i = GPOINTER_TO_INT (list->data)) == row ||
!(work = g_list_nth (clist->row_list, i)))
continue;
-
+
GTK_CLIST_ROW (work)->state = GTK_STATE_NORMAL;
if (CLIST_UNFROZEN (clist) &&
gtk_clist_row_is_visible (clist, i) != GTK_VISIBILITY_NONE)
- GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, i,
- GTK_CLIST_ROW (work));
+ GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, i,
+ GTK_CLIST_ROW (work));
}
}
real_undo_selection (GtkCList *clist)
{
GList *work;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist)) ||
clist->selection_mode != GTK_SELECTION_EXTENDED)
return;
-
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
-
+
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
+
if (!(clist->undo_selection || clist->undo_unselection))
{
gtk_clist_unselect_all (clist);
return;
}
-
+
for (work = clist->undo_selection; work; work = work->next)
gtk_signal_emit (GTK_OBJECT (clist), clist_signals[SELECT_ROW],
GPOINTER_TO_INT (work->data), -1, NULL);
-
+
for (work = clist->undo_unselection; work; work = work->next)
{
/* g_print ("unselect %d\n",GPOINTER_TO_INT (work->data)); */
gtk_signal_emit (GTK_OBJECT (clist), clist_signals[UNSELECT_ROW],
GPOINTER_TO_INT (work->data), -1, NULL);
}
-
+
if (GTK_WIDGET_HAS_FOCUS(clist) && clist->focus_row != clist->undo_anchor)
{
gtk_clist_draw_focus (GTK_WIDGET (clist));
clist->focus_row = clist->undo_anchor;
clist->undo_anchor = -1;
-
+
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
clist->undo_selection = NULL;
clist->undo_unselection = NULL;
-
+
if (ROW_TOP_YPIXEL (clist, clist->focus_row) + clist->row_height >
clist->clist_window_height)
gtk_clist_moveto (clist, clist->focus_row, -1, 1, 0);
if (clist->selection_mode != GTK_SELECTION_EXTENDED || clist->anchor >= 0)
return;
-
+
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
clist->undo_selection = NULL;
clist->undo_unselection = NULL;
-
+
if (add_mode)
fake_toggle_row (clist, anchor);
else
{
- GTK_CLIST_CLASS_FW (clist)->fake_unselect_all (clist, anchor);
+ GTK_CLIST_GET_CLASS (clist)->fake_unselect_all (clist, anchor);
clist->anchor_state = GTK_STATE_SELECTED;
}
-
+
clist->anchor = anchor;
clist->drag_pos = anchor;
clist->undo_anchor = undo_anchor;
gint row;
GList *list;
GtkCListRow *clist_row;
-
+
if (clist->selection_mode != GTK_SELECTION_EXTENDED)
return;
-
+
if (clist->anchor < 0 || clist->drag_pos < 0)
return;
-
+
gtk_clist_freeze (clist);
-
+
i = MIN (clist->anchor, clist->drag_pos);
e = MAX (clist->anchor, clist->drag_pos);
-
+
if (clist->undo_selection)
{
list = clist->selection;
}
}
}
-
+
if (clist->anchor < clist->drag_pos)
{
for (list = g_list_nth (clist->row_list, i); i <= e;
for (list = clist->undo_unselection; list; list = list->next)
gtk_signal_emit (GTK_OBJECT (clist), clist_signals[SELECT_ROW],
GPOINTER_TO_INT (list->data), -1, event);
-
+
clist->anchor = -1;
clist->drag_pos = -1;
-
+
gtk_clist_thaw (clist);
}
gint h1 = 0;
gint h2 = 0;
gint top;
-
+
if (clist->selection_mode != GTK_SELECTION_EXTENDED || clist->anchor == -1)
return;
-
+
if (row < 0)
row = 0;
if (row >= clist->rows)
row = clist->rows - 1;
-
+
/* extending downwards */
if (row > clist->drag_pos && clist->anchor <= clist->drag_pos)
{
else
e1 = row - 1;
}
-
+
clist->drag_pos = row;
-
+
area.x = 0;
area.width = clist->clist_window_width;
-
+
/* restore the elements between s1 and e1 */
if (s1 >= 0)
{
i++, list = list->next)
if (GTK_CLIST_ROW (list)->selectable)
{
- if (GTK_CLIST_CLASS_FW (clist)->selection_find (clist, i, list))
+ if (GTK_CLIST_GET_CLASS (clist)->selection_find (clist, i, list))
GTK_CLIST_ROW (list)->state = GTK_STATE_SELECTED;
else
GTK_CLIST_ROW (list)->state = GTK_STATE_NORMAL;
}
-
+
top = ROW_TOP_YPIXEL (clist, clist->focus_row);
-
+
if (top + clist->row_height <= 0)
{
area.y = 0;
gtk_clist_moveto (clist, clist->focus_row, -1, 0, 0);
else if (top + clist->row_height > clist->clist_window_height)
gtk_clist_moveto (clist, clist->focus_row, -1, 1, 0);
-
+
y1 = ROW_TOP_YPIXEL (clist, s1) - 1;
h1 = (e1 - s1 + 1) * (clist->row_height + CELL_SPACING);
}
-
+
/* extend the selection between s2 and e2 */
if (s2 >= 0)
{
if (GTK_CLIST_ROW (list)->selectable &&
GTK_CLIST_ROW (list)->state != clist->anchor_state)
GTK_CLIST_ROW (list)->state = clist->anchor_state;
-
+
top = ROW_TOP_YPIXEL (clist, clist->focus_row);
-
+
if (top + clist->row_height <= 0)
{
area.y = 0;
gtk_clist_moveto (clist, clist->focus_row, -1, 0, 0);
else if (top + clist->row_height > clist->clist_window_height)
gtk_clist_moveto (clist, clist->focus_row, -1, 1, 0);
-
+
y2 = ROW_TOP_YPIXEL (clist, s2) - 1;
h2 = (e2 - s2 + 1) * (clist->row_height + CELL_SPACING);
}
-
+
area.y = MAX (0, MIN (y1, y2));
if (area.y > clist->clist_window_height)
area.y = 0;
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
return;
-
+
set_anchor (clist, GTK_CLIST_ADD_MODE(clist), clist->focus_row,
clist->focus_row);
}
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_FOCUS(clist))
return;
-
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
}
static void
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist)) ||
clist->selection_mode != GTK_SELECTION_EXTENDED)
return;
-
+
if (auto_start_selection)
set_anchor (clist, GTK_CLIST_ADD_MODE(clist), clist->focus_row,
clist->focus_row);
else if (clist->anchor == -1)
return;
-
+
move_focus_row (clist, scroll_type, position);
-
+
if (ROW_TOP_YPIXEL (clist, clist->focus_row) + clist->row_height >
clist->clist_window_height)
gtk_clist_moveto (clist, clist->focus_row, -1, 1, 0);
else if (ROW_TOP_YPIXEL (clist, clist->focus_row) < 0)
gtk_clist_moveto (clist, clist->focus_row, -1, 0, 0);
-
+
update_extended_selection (clist, clist->focus_row);
}
{
GList *list;
gint d;
-
+
if (mode == SYNC_INSERT)
d = 1;
else
d = -1;
-
+
if (clist->focus_row >= row)
{
if (d > 0 || clist->focus_row > row)
else if (clist->focus_row >= clist->rows)
clist->focus_row = clist->rows - 1;
}
-
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
-
+
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
+
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
clist->undo_selection = NULL;
clist->undo_unselection = NULL;
-
+
clist->anchor = -1;
clist->drag_pos = -1;
clist->undo_anchor = clist->focus_row;
-
+
list = clist->selection;
-
+
while (list)
{
if (GPOINTER_TO_INT (list->data) >= row)
{
gint i;
GtkCList *clist;
-
+
g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_CLIST (object));
-
+
clist = GTK_CLIST (object);
-
+
/* freeze the list */
clist->freeze_count++;
-
+
/* get rid of all the rows */
gtk_clist_clear (clist);
-
+
/* Since we don't have a _remove method, unparent the children
* instead of destroying them so the focus will be unset properly.
* (For other containers, the _remove method takes care of the
* unparent) The destroy will happen when the refcount drops
* to zero.
*/
-
+
/* unref adjustments */
if (clist->hadjustment)
{
gtk_object_unref (GTK_OBJECT (clist->vadjustment));
clist->vadjustment = NULL;
}
-
+
remove_grab (clist);
-
+
/* destroy the column buttons */
for (i = 0; i < clist->columns; i++)
if (clist->column[i].button)
gtk_widget_unparent (clist->column[i].button);
clist->column[i].button = NULL;
}
-
+
if (GTK_OBJECT_CLASS (parent_class)->destroy)
(*GTK_OBJECT_CLASS (parent_class)->destroy) (object);
}
static void
-gtk_clist_finalize (GtkObject *object)
+gtk_clist_finalize (GObject *object)
{
GtkCList *clist;
-
- g_return_if_fail (object != NULL);
+
g_return_if_fail (GTK_IS_CLIST (object));
-
+
clist = GTK_CLIST (object);
-
+
columns_delete (clist);
-
+
g_mem_chunk_destroy (clist->cell_mem_chunk);
g_mem_chunk_destroy (clist->row_mem_chunk);
-
- if (GTK_OBJECT_CLASS (parent_class)->finalize)
- (*GTK_OBJECT_CLASS (parent_class)->finalize) (object);
+
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
/* GTKWIDGET
gint border_width;
gint i;
gint j;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CLIST (widget));
-
+
clist = GTK_CLIST (widget);
-
+
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
-
+
border_width = GTK_CONTAINER (widget)->border_width;
attributes.window_type = GDK_WINDOW_CHILD;
GDK_KEY_PRESS_MASK |
GDK_KEY_RELEASE_MASK);
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
-
+
/* main window */
widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
&attributes, attributes_mask);
gdk_window_set_user_data (widget->window, clist);
-
+
widget->style = gtk_style_attach (widget->style, widget->window);
-
+
gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
-
+
/* column-title window */
-
+
attributes.x = clist->column_title_area.x;
attributes.y = clist->column_title_area.y;
attributes.width = clist->column_title_area.width;
clist->title_window = gdk_window_new (widget->window, &attributes,
attributes_mask);
gdk_window_set_user_data (clist->title_window, clist);
-
+
gtk_style_set_background (widget->style, clist->title_window,
GTK_STATE_NORMAL);
gdk_window_show (clist->title_window);
-
+
/* set things up so column buttons are drawn in title window */
for (i = 0; i < clist->columns; i++)
if (clist->column[i].button)
gtk_widget_set_parent_window (clist->column[i].button,
clist->title_window);
-
+
/* clist-window */
attributes.x = (clist->internal_allocation.x +
widget->style->klass->xthickness);
clist->clist_window = gdk_window_new (widget->window, &attributes,
attributes_mask);
gdk_window_set_user_data (clist->clist_window, clist);
-
+
gdk_window_set_background (clist->clist_window,
&widget->style->base[GTK_STATE_NORMAL]);
gdk_window_show (clist->clist_window);
gdk_window_get_size (clist->clist_window, &clist->clist_window_width,
&clist->clist_window_height);
-
+
/* create resize windows */
attributes.wclass = GDK_INPUT_ONLY;
attributes.event_mask = (GDK_BUTTON_PRESS_MASK |
attributes_mask = GDK_WA_CURSOR;
attributes.cursor = gdk_cursor_new (GDK_SB_H_DOUBLE_ARROW);
clist->cursor_drag = attributes.cursor;
-
+
attributes.x = LIST_WIDTH (clist) + 1;
attributes.y = 0;
attributes.width = 0;
attributes.height = 0;
-
+
for (i = 0; i < clist->columns; i++)
{
clist->column[i].window = gdk_window_new (clist->title_window,
&attributes, attributes_mask);
gdk_window_set_user_data (clist->column[i].window, clist);
}
-
+
/* This is slightly less efficient than creating them with the
* right size to begin with, but easier
*/
size_allocate_title_buttons (clist);
-
+
/* GCs */
clist->fg_gc = gdk_gc_new (widget->window);
clist->bg_gc = gdk_gc_new (widget->window);
/* We'll use this gc to do scrolling as well */
gdk_gc_set_exposures (clist->fg_gc, TRUE);
-
+
values.foreground = (widget->style->white.pixel==0 ?
widget->style->black:widget->style->white);
values.function = GDK_XOR;
GDK_GC_FOREGROUND |
GDK_GC_FUNCTION |
GDK_GC_SUBWINDOW);
-
+
/* attach optional row/cell styles, allocate foreground/background colors */
list = clist->row_list;
for (i = 0; i < clist->rows; i++)
{
clist_row = list->data;
list = list->next;
-
+
if (clist_row->style)
clist_row->style = gtk_style_attach (clist_row->style,
clist->clist_window);
-
+
if (clist_row->fg_set || clist_row->bg_set)
{
GdkColormap *colormap;
-
+
colormap = gtk_widget_get_colormap (widget);
if (clist_row->fg_set)
gdk_color_alloc (colormap, &clist_row->foreground);
{
gint i;
GtkCList *clist;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CLIST (widget));
-
+
clist = GTK_CLIST (widget);
-
+
/* freeze the list */
clist->freeze_count++;
-
+
if (GTK_WIDGET_MAPPED (widget))
gtk_clist_unmap (widget);
-
+
GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
-
+
/* detach optional row/cell styles */
if (GTK_WIDGET_REALIZED (widget))
{
GtkCListRow *clist_row;
GList *list;
gint j;
-
+
list = clist->row_list;
for (i = 0; i < clist->rows; i++)
{
clist_row = list->data;
list = list->next;
-
+
if (clist_row->style)
gtk_style_detach (clist_row->style);
for (j = 0; j < clist->columns; j++)
gtk_style_detach (clist_row->cell[j].style);
}
}
-
+
gdk_cursor_destroy (clist->cursor_drag);
gdk_gc_destroy (clist->xor_gc);
gdk_gc_destroy (clist->fg_gc);
gdk_gc_destroy (clist->bg_gc);
-
+
for (i = 0; i < clist->columns; i++)
{
if (clist->column[i].button)
clist->column[i].window = NULL;
}
}
-
+
gdk_window_set_user_data (clist->clist_window, NULL);
gdk_window_destroy (clist->clist_window);
clist->clist_window = NULL;
-
+
gdk_window_set_user_data (clist->title_window, NULL);
gdk_window_destroy (clist->title_window);
clist->title_window = NULL;
-
+
clist->cursor_drag = NULL;
clist->xor_gc = NULL;
clist->fg_gc = NULL;
clist->bg_gc = NULL;
-
+
if (GTK_WIDGET_CLASS (parent_class)->unrealize)
(* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
}
{
gint i;
GtkCList *clist;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CLIST (widget));
-
+
clist = GTK_CLIST (widget);
-
+
if (!GTK_WIDGET_MAPPED (widget))
{
GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
-
+
/* map column buttons */
for (i = 0; i < clist->columns; i++)
{
gdk_window_raise (clist->column[i].window);
gdk_window_show (clist->column[i].window);
}
-
+
gdk_window_show (clist->title_window);
gdk_window_show (clist->clist_window);
gdk_window_show (widget->window);
-
+
/* unfreeze the list */
clist->freeze_count = 0;
}
{
gint i;
GtkCList *clist;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CLIST (widget));
-
+
clist = GTK_CLIST (widget);
-
+
if (GTK_WIDGET_MAPPED (widget))
{
GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
-
+
if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
{
remove_grab (clist);
-
- GTK_CLIST_CLASS_FW (widget)->resync_selection (clist, NULL);
-
+
+ GTK_CLIST_GET_CLASS (widget)->resync_selection (clist, NULL);
+
clist->click_cell.row = -1;
clist->click_cell.column = -1;
clist->drag_button = 0;
-
+
if (GTK_CLIST_IN_DRAG(clist))
{
gpointer drag_data;
-
+
GTK_CLIST_UNSET_FLAG (clist, CLIST_IN_DRAG);
drag_data = gtk_object_get_data (GTK_OBJECT (clist),
"gtk-site-data");
drag_data);
}
}
-
+
for (i = 0; i < clist->columns; i++)
if (clist->column[i].window)
gdk_window_hide (clist->column[i].window);
-
+
gdk_window_hide (clist->clist_window);
gdk_window_hide (clist->title_window);
gdk_window_hide (widget->window);
-
+
/* unmap column buttons */
for (i = 0; i < clist->columns; i++)
if (clist->column[i].button &&
GTK_WIDGET_MAPPED (clist->column[i].button))
gtk_widget_unmap (clist->column[i].button);
-
+
/* freeze the list */
clist->freeze_count++;
}
gint border_width;
GdkRectangle child_area;
int i;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CLIST (widget));
g_return_if_fail (area != NULL);
-
+
if (GTK_WIDGET_DRAWABLE (widget))
{
clist = GTK_CLIST (widget);
border_width = GTK_CONTAINER (widget)->border_width;
-
+
gdk_window_clear_area (widget->window,
area->x - border_width,
area->y - border_width,
area->width, area->height);
-
+
/* draw list shadow/border */
gtk_draw_shadow (widget->style, widget->window,
GTK_STATE_NORMAL, clist->shadow_type,
clist->clist_window_height +
(2 * widget->style->klass->ythickness) +
clist->column_title_area.height);
-
+
gdk_window_clear_area (clist->clist_window, 0, 0, 0, 0);
draw_rows (clist, NULL);
-
+
for (i = 0; i < clist->columns; i++)
{
if (!clist->column[i].visible)
GdkEventExpose *event)
{
GtkCList *clist;
-
+
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
-
+
if (GTK_WIDGET_DRAWABLE (widget))
{
clist = GTK_CLIST (widget);
-
+
/* draw border */
if (event->window == widget->window)
gtk_draw_shadow (widget->style, widget->window,
clist->clist_window_height +
(2 * widget->style->klass->ythickness) +
clist->column_title_area.height);
-
+
/* exposure events on the list */
if (event->window == clist->clist_window)
draw_rows (clist, &event->area);
}
-
+
return FALSE;
}
GtkStyle *previous_style)
{
GtkCList *clist;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CLIST (widget));
-
+
if (GTK_WIDGET_CLASS (parent_class)->style_set)
(*GTK_WIDGET_CLASS (parent_class)->style_set) (widget, previous_style);
-
+
clist = GTK_CLIST (widget);
-
+
if (GTK_WIDGET_REALIZED (widget))
{
gtk_style_set_background (widget->style, widget->window, widget->state);
gtk_style_set_background (widget->style, clist->title_window, GTK_STATE_SELECTED);
gdk_window_set_background (clist->clist_window, &widget->style->base[GTK_STATE_NORMAL]);
}
-
+
/* Fill in data after widget has correct style */
-
+
/* text properties */
if (!GTK_CLIST_ROW_HEIGHT_SET(clist))
{
clist->row_center_offset = 1.5 + (clist->row_height +
widget->style->font->ascent -
widget->style->font->descent - 1) / 2;
-
+
/* Column widths */
if (!GTK_CLIST_AUTO_RESIZE_BLOCKED(clist))
{
gint width;
gint i;
-
+
for (i = 0; i < clist->columns; i++)
if (clist->column[i].auto_resize)
{
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
-
+
if (GTK_WIDGET_CLASS (parent_class)->key_press_event &&
GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, event))
return TRUE;
-
+
switch (event->keyval)
{
case GDK_Tab:
gint row;
gint column;
gint button_actions;
-
+
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
-
+
clist = GTK_CLIST (widget);
-
+
button_actions = clist->button_actions[event->button - 1];
-
+
if (button_actions == GTK_BUTTON_IGNORED)
return FALSE;
-
+
/* selections on the list */
if (event->window == clist->clist_window)
{
x = event->x;
y = event->y;
-
+
if (get_selection_info (clist, x, y, &row, &column))
{
gint old_row = clist->focus_row;
-
+
if (clist->focus_row == -1)
old_row = row;
-
+
if (event->type == GDK_BUTTON_PRESS)
{
GdkEventMask mask = ((1 << (4 + event->button)) |
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON_RELEASE_MASK);
-
+
if (gdk_pointer_grab (clist->clist_window, FALSE, mask,
NULL, NULL, event->time))
return FALSE;
gtk_grab_add (widget);
-
+
clist->click_cell.row = row;
clist->click_cell.column = column;
clist->drag_button = event->button;
{
clist->click_cell.row = -1;
clist->click_cell.column = -1;
-
+
clist->drag_button = 0;
remove_grab (clist);
}
-
+
if (button_actions & GTK_BUTTON_SELECTS)
{
if (GTK_CLIST_ADD_MODE(clist))
clist->focus_row = row;
}
}
-
+
if (!GTK_WIDGET_HAS_FOCUS(widget))
gtk_widget_grab_focus (widget);
-
+
if (button_actions & GTK_BUTTON_SELECTS)
{
switch (clist->selection_mode)
if (clist->anchor != -1)
{
update_extended_selection (clist, clist->focus_row);
- GTK_CLIST_CLASS_FW (clist)->resync_selection
+ GTK_CLIST_GET_CLASS (clist)->resync_selection
(clist, (GdkEvent *) event);
}
gtk_signal_emit (GTK_OBJECT (clist),
row, column, event);
break;
}
-
+
if (event->state & GDK_CONTROL_MASK)
{
if (event->state & GDK_SHIFT_MASK)
}
break;
}
-
+
if (event->state & GDK_SHIFT_MASK)
{
set_anchor (clist, FALSE, old_row, old_row);
update_extended_selection (clist, clist->focus_row);
break;
}
-
+
if (clist->anchor == -1)
set_anchor (clist, FALSE, row, old_row);
else
}
return FALSE;
}
-
+
/* press on resize windows */
for (i = 0; i < clist->columns; i++)
if (clist->column[i].resizeable && clist->column[i].window &&
event->window == clist->column[i].window)
{
gpointer drag_data;
-
+
if (gdk_pointer_grab (clist->column[i].window, FALSE,
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON1_MOTION_MASK |
GDK_BUTTON_RELEASE_MASK,
NULL, NULL, event->time))
return FALSE;
-
+
gtk_grab_add (widget);
GTK_CLIST_SET_FLAG (clist, CLIST_IN_DRAG);
-
+
/* block attached dnd signal handler */
drag_data = gtk_object_get_data (GTK_OBJECT (clist), "gtk-site-data");
if (drag_data)
gtk_signal_handler_block_by_data (GTK_OBJECT (clist), drag_data);
-
+
if (!GTK_WIDGET_HAS_FOCUS(widget))
gtk_widget_grab_focus (widget);
-
+
clist->drag_pos = i;
clist->x_drag = (COLUMN_LEFT_XPIXEL(clist, i) + COLUMN_INSET +
clist->column[i].area.width + CELL_SPACING);
-
+
if (GTK_CLIST_ADD_MODE(clist))
gdk_gc_set_line_attributes (clist->xor_gc, 1, GDK_LINE_SOLID, 0, 0);
draw_xor_line (clist);
{
GtkCList *clist;
gint button_actions;
-
+
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
-
+
clist = GTK_CLIST (widget);
-
+
button_actions = clist->button_actions[event->button - 1];
if (button_actions == GTK_BUTTON_IGNORED)
return FALSE;
-
+
/* release on resize windows */
if (GTK_CLIST_IN_DRAG(clist))
{
gint width;
gint x;
gint i;
-
+
i = clist->drag_pos;
clist->drag_pos = -1;
-
+
/* unblock attached dnd signal handler */
drag_data = gtk_object_get_data (GTK_OBJECT (clist), "gtk-site-data");
if (drag_data)
gtk_signal_handler_unblock_by_data (GTK_OBJECT (clist), drag_data);
-
+
GTK_CLIST_UNSET_FLAG (clist, CLIST_IN_DRAG);
gtk_widget_get_pointer (widget, &x, NULL);
gtk_grab_remove (widget);
gdk_pointer_ungrab (event->time);
-
+
if (clist->x_drag >= 0)
draw_xor_line (clist);
-
+
if (GTK_CLIST_ADD_MODE(clist))
{
gdk_gc_set_line_attributes (clist->xor_gc, 1,
GDK_LINE_ON_OFF_DASH, 0, 0);
gdk_gc_set_dashes (clist->xor_gc, 0, "\4\4", 2);
}
-
+
width = new_column_width (clist, i, &x);
gtk_clist_set_column_width (clist, i, width);
return FALSE;
}
-
+
if (clist->drag_button == event->button)
{
gint row;
gint column;
-
+
clist->drag_button = 0;
clist->click_cell.row = -1;
clist->click_cell.column = -1;
-
+
remove_grab (clist);
-
+
if (button_actions & GTK_BUTTON_SELECTS)
{
switch (clist->selection_mode)
!GTK_WIDGET_CAN_FOCUS (widget) ||
event->x < 0 || event->x >= clist->clist_window_width ||
event->y < 0 || event->y >= clist->clist_window_height)
- GTK_CLIST_CLASS_FW (clist)->resync_selection
+ GTK_CLIST_GET_CLASS (clist)->resync_selection
(clist, (GdkEvent *) event);
break;
case GTK_SELECTION_SINGLE:
gint row;
gint new_width;
gint button_actions = 0;
-
+
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
-
+
clist = GTK_CLIST (widget);
if (!(gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist)))
return FALSE;
-
+
if (clist->drag_button > 0)
button_actions = clist->button_actions[clist->drag_button - 1];
-
+
if (GTK_CLIST_IN_DRAG(clist))
{
if (event->is_hint || event->window != widget->window)
/* x_drag < 0 indicates that the xor line is already invisible */
if (clist->x_drag >= 0)
draw_xor_line (clist);
-
+
clist->x_drag = x;
-
+
if (clist->x_drag >= 0)
draw_xor_line (clist);
}
-
+
if (new_width <= MAX (COLUMN_MIN_WIDTH + 1,
clist->column[clist->drag_pos].min_width + 1))
{
return FALSE;
}
}
-
+
if (event->is_hint || event->window != clist->clist_window)
gdk_window_get_pointer (clist->clist_window, &x, &y, NULL);
else
x = event->x;
y = event->y;
}
-
+
if (GTK_CLIST_REORDERABLE(clist) && button_actions & GTK_BUTTON_DRAGS)
{
/* delayed drag start */
clist->column[clist->click_cell.column].area.width)))
{
GtkTargetList *target_list;
-
+
target_list = gtk_target_list_new (&clist_target_table, 1);
gtk_drag_begin (widget, target_list, GDK_ACTION_MOVE,
clist->drag_button, (GdkEvent *)event);
-
+
}
return TRUE;
}
-
+
/* horizontal autoscrolling */
if (clist->hadjustment && LIST_WIDTH (clist) > clist->clist_window_width &&
(x < 0 || x >= clist->clist_window_width))
{
if (clist->htimer)
return FALSE;
-
+
clist->htimer = gtk_timeout_add
(SCROLL_TIME, (GtkFunction) horizontal_timeout, clist);
-
+
if (!((x < 0 && clist->hadjustment->value == 0) ||
(x >= clist->clist_window_width &&
clist->hadjustment->value ==
move_horizontal (clist, 1 + (x - clist->clist_window_width) / 2);
}
}
-
+
if (GTK_CLIST_IN_DRAG(clist))
return FALSE;
-
+
/* vertical autoscrolling */
row = ROW_FROM_YPIXEL (clist, y);
-
+
/* don't scroll on last pixel row if it's a cell spacing */
if (y == clist->clist_window_height - 1 &&
y == ROW_TOP_YPIXEL (clist, row-1) + clist->row_height)
return FALSE;
-
+
if (LIST_HEIGHT (clist) > clist->clist_window_height &&
(y < 0 || y >= clist->clist_window_height))
{
if (clist->vtimer)
return FALSE;
-
+
clist->vtimer = gtk_timeout_add (SCROLL_TIME,
(GtkFunction) vertical_timeout, clist);
-
+
if (clist->drag_button &&
((y < 0 && clist->focus_row == 0) ||
(y >= clist->clist_window_height &&
clist->focus_row == clist->rows - 1)))
return FALSE;
}
-
+
row = CLAMP (row, 0, clist->rows - 1);
-
+
if (button_actions & GTK_BUTTON_SELECTS &
!gtk_object_get_data (GTK_OBJECT (widget), "gtk-site-data"))
{
if (row == clist->focus_row)
return FALSE;
-
+
gtk_clist_draw_focus (widget);
clist->focus_row = row;
gtk_clist_draw_focus (widget);
-
+
switch (clist->selection_mode)
{
case GTK_SELECTION_BROWSE:
else if (ROW_TOP_YPIXEL(clist, row) + clist->row_height >
clist->clist_window_height)
move_vertical (clist, row, 1);
-
+
return FALSE;
}
{
GtkCList *clist;
gint i;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CLIST (widget));
g_return_if_fail (requisition != NULL);
-
+
clist = GTK_CLIST (widget);
-
+
requisition->width = 0;
requisition->height = 0;
-
+
/* compute the size of the column title (title) area */
clist->column_title_area.height = 0;
if (GTK_CLIST_SHOW_TITLES(clist))
MAX (clist->column_title_area.height,
child_requisition.height);
}
-
+
requisition->width += (widget->style->klass->xthickness +
GTK_CONTAINER (widget)->border_width) * 2;
requisition->height += (clist->column_title_area.height +
(widget->style->klass->ythickness +
GTK_CONTAINER (widget)->border_width) * 2);
-
+
/* if (!clist->hadjustment) */
requisition->width += list_requisition_width (clist);
/* if (!clist->vadjustment) */
GtkCList *clist;
GtkAllocation clist_allocation;
gint border_width;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CLIST (widget));
g_return_if_fail (allocation != NULL);
-
+
clist = GTK_CLIST (widget);
widget->allocation = *allocation;
border_width = GTK_CONTAINER (widget)->border_width;
-
+
if (GTK_WIDGET_REALIZED (widget))
{
gdk_window_move_resize (widget->window,
allocation->width - border_width * 2,
allocation->height - border_width * 2);
}
-
+
/* use internal allocation structure for all the math
* because it's easier than always subtracting the container
* border width */
border_width * 2);
clist->internal_allocation.height = MAX (1, (gint)allocation->height -
border_width * 2);
-
+
/* allocate clist window assuming no scrollbars */
clist_allocation.x = (clist->internal_allocation.x +
widget->style->klass->xthickness);
/* column button allocation */
size_allocate_columns (clist, FALSE);
size_allocate_title_buttons (clist);
-
+
adjust_adjustments (clist, TRUE);
}
{
GtkCList *clist;
guint i;
-
+
g_return_if_fail (container != NULL);
g_return_if_fail (GTK_IS_CLIST (container));
g_return_if_fail (callback != NULL);
-
+
if (!include_internals)
return;
-
+
clist = GTK_CLIST (container);
-
+
/* callback for the column buttons */
for (i = 0; i < clist->columns; i++)
if (clist->column[i].button)
GdkGC **bg_gc)
{
gint fg_state;
-
+
if ((state == GTK_STATE_NORMAL) &&
(GTK_WIDGET (clist)->state == GTK_STATE_INSENSITIVE))
fg_state = GTK_STATE_INSENSITIVE;
else
fg_state = state;
-
+
if (clist_row->cell[column].style)
{
if (style)
else
*bg_gc = GTK_WIDGET (clist)->style->base_gc[state];
}
-
+
if (state != GTK_STATE_SELECTED)
{
if (fg_gc && clist_row->fg_set)
{
gint xsrc = 0;
gint ysrc = 0;
-
+
if (mask)
{
gdk_gc_set_clip_mask (fg_gc, mask);
gdk_gc_set_clip_origin (fg_gc, x, y);
}
-
+
if (x < clip_rectangle->x)
{
xsrc = clip_rectangle->x - x;
}
if (x + width > clip_rectangle->x + clip_rectangle->width)
width = clip_rectangle->x + clip_rectangle->width - x;
-
+
if (y < clip_rectangle->y)
{
ysrc = clip_rectangle->y - y;
}
if (y + height > clip_rectangle->y + clip_rectangle->height)
height = clip_rectangle->y + clip_rectangle->height - y;
-
+
gdk_draw_pixmap (window, fg_gc, pixmap, xsrc, ysrc, x, y, width, height);
gdk_gc_set_clip_origin (fg_gc, 0, 0);
if (mask)
gdk_gc_set_clip_mask (fg_gc, NULL);
-
+
return x + MAX (width, 0);
}
gint last_column;
gint state;
gint i;
-
+
g_return_if_fail (clist != NULL);
-
+
/* bail now if we arn't drawable yet */
if (!GTK_WIDGET_DRAWABLE (clist) || row < 0 || row >= clist->rows)
return;
-
+
widget = GTK_WIDGET (clist);
-
+
/* if the function is passed the pointer to the row instead of null,
* it avoids this expensive lookup */
if (!clist_row)
clist_row = ROW_ELEMENT (clist, row)->data;
-
+
/* rectangle of the entire row */
row_rectangle.x = 0;
row_rectangle.y = ROW_TOP_YPIXEL (clist, row);
row_rectangle.width = clist->clist_window_width;
row_rectangle.height = clist->row_height;
-
+
/* rectangle of the cell spacing above the row */
cell_rectangle.x = 0;
cell_rectangle.y = row_rectangle.y - CELL_SPACING;
cell_rectangle.width = row_rectangle.width;
cell_rectangle.height = CELL_SPACING;
-
+
/* rectangle used to clip drawing operations, its y and height
* positions only need to be set once, so we set them once here.
* the x and width are set withing the drawing loop below once per
* column */
clip_rectangle.y = row_rectangle.y;
clip_rectangle.height = row_rectangle.height;
-
+
if (clist_row->state == GTK_STATE_NORMAL)
{
if (clist_row->fg_set)
if (clist_row->bg_set)
gdk_gc_set_foreground (clist->bg_gc, &clist_row->background);
}
-
+
state = clist_row->state;
-
+
/* draw the cell borders and background */
if (area)
{
intersect_rectangle.y,
intersect_rectangle.width,
intersect_rectangle.height);
-
+
/* the last row has to clear its bottom cell spacing too */
if (clist_row == clist->row_list_end->data)
{
cell_rectangle.y += clist->row_height + CELL_SPACING;
-
+
if (gdk_rectangle_intersect (area, &cell_rectangle,
&intersect_rectangle))
gdk_draw_rectangle (clist->clist_window,
intersect_rectangle.width,
intersect_rectangle.height);
}
-
+
if (!gdk_rectangle_intersect (area, &row_rectangle,&intersect_rectangle))
return;
-
+
}
else
{
cell_rectangle.y,
cell_rectangle.width,
cell_rectangle.height);
-
+
/* the last row has to clear its bottom cell spacing too */
if (clist_row == clist->row_list_end->data)
{
cell_rectangle.y += clist->row_height + CELL_SPACING;
-
+
gdk_draw_rectangle (clist->clist_window,
widget->style->base_gc[GTK_STATE_ACTIVE],
TRUE,
for (last_column = clist->columns - 1;
last_column >= 0 && !clist->column[last_column].visible; last_column--)
;
-
+
/* iterate and draw all the columns (row cells) and draw their contents */
for (i = 0; i < clist->columns; i++)
{
GtkStyle *style;
GdkGC *fg_gc;
GdkGC *bg_gc;
-
+
gint width;
gint height;
gint pixmap_width;
gint offset = 0;
gint row_center_offset;
-
+
if (!clist->column[i].visible)
continue;
-
+
get_cell_style (clist, clist_row, state, i, &style, &fg_gc, &bg_gc);
-
+
clip_rectangle.x = clist->column[i].area.x + clist->hoffset;
clip_rectangle.width = clist->column[i].area.width;
-
+
/* calculate clipping region clipping region */
clip_rectangle.x -= COLUMN_INSET + CELL_SPACING;
clip_rectangle.width += (2 * COLUMN_INSET + CELL_SPACING +
if (area && !gdk_rectangle_intersect (area, &clip_rectangle,
&intersect_rectangle))
continue;
-
+
gdk_draw_rectangle (clist->clist_window, bg_gc, TRUE,
rect->x, rect->y, rect->width, rect->height);
-
+
clip_rectangle.x += COLUMN_INSET + CELL_SPACING;
clip_rectangle.width -= (2 * COLUMN_INSET + CELL_SPACING +
(i == last_column) * CELL_SPACING);
-
+
/* calculate real width for column justification */
pixmap_width = 0;
offset = 0;
continue;
break;
}
-
+
switch (clist->column[i].justification)
{
case GTK_JUSTIFY_LEFT:
(clip_rectangle.width / 2) - (width / 2));
break;
};
-
+
/* Draw Text and/or Pixmap */
switch (clist_row->cell[i].type)
{
case GTK_CELL_TEXT:
if (style != GTK_WIDGET (clist)->style)
row_center_offset = (((clist->row_height - style->font->ascent -
- style->font->descent - 1) / 2) + 1.5 +
+ style->font->descent - 1) / 2) + 1.5 +
style->font->ascent);
else
row_center_offset = clist->row_center_offset;
-
+
gdk_gc_set_clip_rectangle (fg_gc, &clip_rectangle);
gdk_draw_string (clist->clist_window, style->font, fg_gc,
offset,
break;
}
}
-
+
/* draw focus rectangle */
if (clist->focus_row == row &&
GTK_WIDGET_CAN_FOCUS (widget) && GTK_WIDGET_HAS_FOCUS(widget))
gint i;
gint first_row;
gint last_row;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (clist->row_height == 0 ||
!GTK_WIDGET_DRAWABLE (clist))
return;
-
+
if (area)
{
first_row = ROW_FROM_YPIXEL (clist, area->y);
first_row = ROW_FROM_YPIXEL (clist, 0);
last_row = ROW_FROM_YPIXEL (clist, clist->clist_window_height);
}
-
+
/* this is a small special case which exposes the bottom cell line
* on the last row -- it might go away if I change the wall the cell
* spacings are drawn
*/
if (clist->rows == first_row)
first_row--;
-
+
list = ROW_ELEMENT (clist, first_row);
i = first_row;
while (list)
{
clist_row = list->data;
list = list->next;
-
+
if (i > last_row)
return;
-
- GTK_CLIST_CLASS_FW (clist)->draw_row (clist, area, i, clist_row);
+
+ GTK_CLIST_GET_CLASS (clist)->draw_row (clist, area, i, clist_row);
i++;
}
-
+
if (!area)
gdk_window_clear_area (clist->clist_window, 0,
ROW_TOP_YPIXEL (clist, i), 0, 0);
draw_xor_line (GtkCList *clist)
{
GtkWidget *widget;
-
+
g_return_if_fail (clist != NULL);
-
+
widget = GTK_WIDGET (clist);
-
+
gdk_draw_line (widget->window, clist->xor_gc,
clist->x_drag,
widget->style->klass->ythickness,
gint *column)
{
gint trow, tcol;
-
+
g_return_val_if_fail (clist != NULL, 0);
g_return_val_if_fail (GTK_IS_CLIST (clist), 0);
-
+
/* bounds checking, return false if the user clicked
* on a blank area */
trow = ROW_FROM_YPIXEL (clist, y);
if (trow >= clist->rows)
return 0;
-
+
if (row)
*row = trow;
-
+
tcol = COLUMN_FROM_XPIXEL (clist, x);
if (tcol >= clist->columns)
return 0;
-
+
if (column)
*column = tcol;
-
+
return 1;
}
clist->vadjustment->step_increment = clist->row_height;
clist->vadjustment->lower = 0;
clist->vadjustment->upper = LIST_HEIGHT (clist);
-
+
if (clist->clist_window_height - clist->voffset > LIST_HEIGHT (clist) ||
(clist->voffset + (gint)clist->vadjustment->value) != 0)
{
}
gtk_signal_emit_by_name (GTK_OBJECT (clist->vadjustment), "changed");
}
-
+
if (clist->hadjustment)
{
clist->hadjustment->page_size = clist->clist_window_width;
clist->hadjustment->step_increment = 10;
clist->hadjustment->lower = 0;
clist->hadjustment->upper = LIST_WIDTH (clist);
-
+
if (clist->clist_window_width - clist->hoffset > LIST_WIDTH (clist) ||
(clist->hoffset + (gint)clist->hadjustment->value) != 0)
{
}
gtk_signal_emit_by_name (GTK_OBJECT (clist->hadjustment), "changed");
}
-
+
if (!block_resize && (!clist->vadjustment || !clist->hadjustment))
{
GtkWidget *widget;
GtkRequisition requisition;
-
+
widget = GTK_WIDGET (clist);
gtk_widget_size_request (widget, &requisition);
-
+
if ((!clist->hadjustment &&
requisition.width != widget->allocation.width) ||
(!clist->vadjustment &&
gpointer data)
{
GtkCList *clist;
-
+
g_return_if_fail (adjustment != NULL);
g_return_if_fail (data != NULL);
-
+
clist = GTK_CLIST (data);
}
gpointer data)
{
GtkCList *clist;
-
+
g_return_if_fail (adjustment != NULL);
g_return_if_fail (data != NULL);
-
+
clist = GTK_CLIST (data);
}
GtkCList *clist;
GdkRectangle area;
gint diff, value;
-
+
g_return_if_fail (adjustment != NULL);
g_return_if_fail (data != NULL);
g_return_if_fail (GTK_IS_CLIST (data));
-
+
clist = GTK_CLIST (data);
-
+
if (!GTK_WIDGET_DRAWABLE (clist) || adjustment != clist->vadjustment)
return;
-
+
value = adjustment->value;
-
+
if (value > -clist->voffset)
{
/* scroll down */
diff = value + clist->voffset;
-
+
/* we have to re-draw the whole screen here... */
if (diff >= clist->clist_window_height)
{
draw_rows (clist, NULL);
return;
}
-
+
if ((diff != 0) && (diff != clist->clist_window_height))
gdk_window_copy_area (clist->clist_window, clist->fg_gc,
0, 0, clist->clist_window, 0, diff,
clist->clist_window_width,
clist->clist_window_height - diff);
-
+
area.x = 0;
area.y = clist->clist_window_height - diff;
area.width = clist->clist_window_width;
{
/* scroll up */
diff = -clist->voffset - value;
-
+
/* we have to re-draw the whole screen here... */
if (diff >= clist->clist_window_height)
{
draw_rows (clist, NULL);
return;
}
-
+
if ((diff != 0) && (diff != clist->clist_window_height))
gdk_window_copy_area (clist->clist_window, clist->fg_gc,
0, diff, clist->clist_window, 0, 0,
clist->clist_window_width,
clist->clist_window_height - diff);
-
+
area.x = 0;
area.y = 0;
area.width = clist->clist_window_width;
area.height = diff;
}
-
+
clist->voffset = -value;
if ((diff != 0) && (diff != clist->clist_window_height))
check_exposures (clist);
-
+
draw_rows (clist, &area);
}
gint y = 0;
gint diff = 0;
gint value;
-
+
g_return_if_fail (adjustment != NULL);
g_return_if_fail (data != NULL);
g_return_if_fail (GTK_IS_CLIST (data));
-
+
clist = GTK_CLIST (data);
-
+
if (!GTK_WIDGET_DRAWABLE (clist) || adjustment != clist->hadjustment)
return;
-
+
value = adjustment->value;
-
+
/* move the column buttons and resize windows */
for (i = 0; i < clist->columns; i++)
{
}
}
}
-
+
if (value > -clist->hoffset)
{
/* scroll right */
draw_rows (clist, NULL);
return;
}
-
+
if (GTK_WIDGET_CAN_FOCUS(clist) && GTK_WIDGET_HAS_FOCUS(clist) &&
!GTK_CLIST_CHILD_HAS_FOCUS(clist) && GTK_CLIST_ADD_MODE(clist))
{
y = ROW_TOP_YPIXEL (clist, clist->focus_row);
-
+
gdk_draw_rectangle (clist->clist_window, clist->xor_gc, FALSE, 0, y,
clist->clist_window_width - 1,
clist->row_height - 1);
0,
clist->clist_window_width - diff,
clist->clist_window_height);
-
+
area.x = clist->clist_window_width - diff;
}
else
/* scroll left */
if (!(diff = -clist->hoffset - value))
return;
-
+
clist->hoffset = -value;
/* we have to re-draw the whole screen here... */
clist->clist_window_width - 1,
clist->row_height - 1);
}
-
+
gdk_window_copy_area (clist->clist_window,
clist->fg_gc,
diff, 0,
0,
clist->clist_window_width - diff,
clist->clist_window_height);
-
+
area.x = 0;
}
-
+
area.y = 0;
area.width = diff;
area.height = clist->clist_window_height;
-
+
check_exposures (clist);
-
+
if (GTK_WIDGET_CAN_FOCUS(clist) && GTK_WIDGET_HAS_FOCUS(clist) &&
!GTK_CLIST_CHILD_HAS_FOCUS(clist))
{
check_exposures (GtkCList *clist)
{
GdkEvent *event;
-
+
if (!GTK_WIDGET_REALIZED (clist))
return;
-
+
/* Make sure graphics expose events are processed before scrolling
* again */
while ((event = gdk_event_get_graphics_expose (clist->clist_window)) != NULL)
{
GtkCListColumn *column;
gint i;
-
+
column = g_new (GtkCListColumn, clist->columns);
-
+
for (i = 0; i < clist->columns; i++)
{
column[i].area.x = 0;
column[i].button_passive = FALSE;
column[i].justification = GTK_JUSTIFY_LEFT;
}
-
+
return column;
}
{
if (clist->column[column].title)
g_free (clist->column[column].title);
-
+
clist->column[column].title = g_strdup (title);
}
columns_delete (GtkCList *clist)
{
gint i;
-
+
for (i = 0; i < clist->columns; i++)
if (clist->column[i].title)
g_free (clist->column[i].title);
-
+
g_free (clist->column);
}
{
int i;
GtkCListRow *clist_row;
-
+
clist_row = g_chunk_new (GtkCListRow, clist->row_mem_chunk);
clist_row->cell = g_chunk_new (GtkCell, clist->cell_mem_chunk);
-
+
for (i = 0; i < clist->columns; i++)
{
clist_row->cell[i].type = GTK_CELL_EMPTY;
clist_row->cell[i].horizontal = 0;
clist_row->cell[i].style = NULL;
}
-
+
clist_row->fg_set = FALSE;
clist_row->bg_set = FALSE;
clist_row->style = NULL;
clist_row->state = GTK_STATE_NORMAL;
clist_row->data = NULL;
clist_row->destroy = NULL;
-
+
return clist_row;
}
GtkCListRow *clist_row)
{
gint i;
-
+
for (i = 0; i < clist->columns; i++)
{
- GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ GTK_CLIST_GET_CLASS (clist)->set_cell_contents
(clist, clist_row, i, GTK_CELL_EMPTY, NULL, 0, NULL, NULL);
if (clist_row->cell[i].style)
{
gtk_style_unref (clist_row->cell[i].style);
}
}
-
+
if (clist_row->style)
{
if (GTK_WIDGET_REALIZED (clist))
gtk_style_detach (clist_row->style);
gtk_style_unref (clist_row->style);
}
-
+
if (clist_row->destroy)
clist_row->destroy (clist_row->data);
-
+
g_mem_chunk_free (clist->cell_mem_chunk, clist_row->cell);
g_mem_chunk_free (clist->row_mem_chunk, clist_row);
}
GtkCList *clist;
GtkWidget *focus_child;
gint old_row;
-
+
g_return_val_if_fail (container != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CLIST (container), FALSE);
-
+
if (!GTK_WIDGET_IS_SENSITIVE (container))
return FALSE;
clist = GTK_CLIST (container);
focus_child = container->focus_child;
old_row = clist->focus_row;
-
+
switch (direction)
{
case GTK_DIR_LEFT:
return TRUE;
gtk_container_set_focus_child (container, NULL);
return FALSE;
- }
+ }
gtk_widget_grab_focus (GTK_WIDGET (container));
return TRUE;
case GTK_DIR_DOWN:
if (GTK_CLIST_CHILD_HAS_FOCUS(clist))
{
gboolean tf = FALSE;
-
+
if (((focus_child && direction == GTK_DIR_DOWN) ||
!(tf = title_focus (clist, GTK_DIR_TAB_FORWARD)))
&& clist->rows)
if (clist->focus_row < 0)
{
clist->focus_row = 0;
-
+
if ((clist->selection_mode == GTK_SELECTION_BROWSE ||
clist->selection_mode == GTK_SELECTION_EXTENDED) &&
!clist->selection)
gtk_widget_grab_focus (GTK_WIDGET (container));
return TRUE;
}
-
+
if (tf)
return TRUE;
}
gtk_widget_grab_focus (GTK_WIDGET (container));
return TRUE;
}
-
+
GTK_CLIST_SET_FLAG (clist, CLIST_CHILD_HAS_FOCUS);
-
+
if (title_focus (clist, direction))
return TRUE;
-
+
break;
default:
break;
}
-
+
gtk_container_set_focus_child (container, NULL);
return FALSE;
}
gtk_clist_draw_focus (GtkWidget *widget)
{
GtkCList *clist;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CLIST (widget));
-
+
if (!GTK_WIDGET_DRAWABLE (widget) || !GTK_WIDGET_CAN_FOCUS (widget))
return;
-
+
clist = GTK_CLIST (widget);
if (clist->focus_row >= 0)
gdk_draw_rectangle (clist->clist_window, clist->xor_gc, FALSE,
GdkEventFocus *event)
{
GtkCList *clist;
-
+
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
-
+
GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
GTK_CLIST_UNSET_FLAG (widget, CLIST_CHILD_HAS_FOCUS);
-
+
clist = GTK_CLIST (widget);
-
+
if (clist->selection_mode == GTK_SELECTION_BROWSE &&
clist->selection == NULL && clist->focus_row > -1)
{
GList *list;
-
+
list = g_list_nth (clist->row_list, clist->focus_row);
if (list && GTK_CLIST_ROW (list)->selectable)
gtk_signal_emit (GTK_OBJECT (clist), clist_signals[SELECT_ROW],
}
else
gtk_widget_draw_focus (widget);
-
+
return FALSE;
}
GdkEventFocus *event)
{
GtkCList *clist;
-
+
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
-
+
GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
GTK_CLIST_SET_FLAG (widget, CLIST_CHILD_HAS_FOCUS);
-
+
gtk_widget_draw_focus (widget);
clist = GTK_CLIST (widget);
-
- GTK_CLIST_CLASS_FW (widget)->resync_selection (clist, (GdkEvent *) event);
-
+
+ GTK_CLIST_GET_CLASS (widget)->resync_selection (clist, (GdkEvent *) event);
+
return FALSE;
}
{
g_return_if_fail (container != NULL);
g_return_if_fail (GTK_IS_CLIST (container));
-
+
if (child)
{
g_return_if_fail (GTK_IS_WIDGET (child));
GTK_CLIST_SET_FLAG (container, CLIST_CHILD_HAS_FOCUS);
}
-
+
parent_class->set_focus_child (container, child);
}
gint d = 1;
gint i = 0;
gint j;
-
+
if (!GTK_CLIST_SHOW_TITLES(clist))
return FALSE;
-
+
focus_child = GTK_CONTAINER (clist)->focus_child;
-
+
for (last_column = clist->columns - 1;
last_column >= 0 && !clist->column[last_column].visible; last_column--)
;
}
break;
}
-
+
if (focus_child)
while (i < clist->columns)
{
}
i++;
}
-
+
j = i;
-
+
if (!return_val)
while (j >= 0 && j < clist->columns)
{
gfloat position)
{
GtkWidget *widget;
-
+
g_return_if_fail (clist != 0);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
widget = GTK_WIDGET (clist);
-
+
switch (scroll_type)
{
case GTK_SCROLL_STEP_BACKWARD:
{
gint column = 0;
gint last_column;
-
+
g_return_if_fail (clist != 0);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
return;
-
+
for (last_column = clist->columns - 1;
last_column >= 0 && !clist->column[last_column].visible; last_column--)
;
-
+
switch (scroll_type)
{
case GTK_SCROLL_STEP_BACKWARD:
{
gint vis_columns = 0;
gint i;
-
+
for (i = 0; i <= last_column; i++)
if (clist->column[i].visible)
vis_columns++;
-
+
column = position * vis_columns;
-
+
for (i = 0; i <= last_column && column > 0; i++)
if (clist->column[i].visible)
column--;
-
+
column = i;
}
else
default:
break;
}
-
+
if (COLUMN_LEFT_XPIXEL (clist, column) < CELL_SPACING + COLUMN_INSET)
gtk_clist_moveto (clist, -1, column, 0, 0);
else if (COLUMN_LEFT_XPIXEL (clist, column) + CELL_SPACING + COLUMN_INSET - 1
gfloat position)
{
gint old_focus_row;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
return;
-
+
switch (clist->selection_mode)
{
case GTK_SELECTION_EXTENDED:
if (clist->anchor >= 0)
return;
case GTK_SELECTION_BROWSE:
-
+
old_focus_row = clist->focus_row;
move_focus_row (clist, scroll_type, position);
-
+
if (old_focus_row != clist->focus_row)
{
if (clist->selection_mode == GTK_SELECTION_BROWSE)
clist->undo_anchor = old_focus_row;
}
}
-
+
switch (gtk_clist_row_is_visible (clist, clist->focus_row))
{
case GTK_VISIBILITY_NONE:
break;
default:
move_focus_row (clist, scroll_type, position);
-
+
if (ROW_TOP_YPIXEL (clist, clist->focus_row) + clist->row_height >
clist->clist_window_height)
gtk_clist_moveto (clist, clist->focus_row, -1, 1, 0);
gint diff)
{
gfloat value;
-
+
if (!clist->hadjustment)
return;
-
+
value = CLAMP (clist->hadjustment->value + diff, 0.0,
clist->hadjustment->upper - clist->hadjustment->page_size);
gtk_adjustment_set_value(clist->hadjustment, value);
gfloat align)
{
gfloat value;
-
+
if (!clist->vadjustment)
return;
-
+
value = (ROW_TOP_YPIXEL (clist, row) - clist->voffset -
align * (clist->clist_window_height - clist->row_height) +
(2 * align - 1) * CELL_SPACING);
-
+
if (value + clist->vadjustment->page_size > clist->vadjustment->upper)
value = clist->vadjustment->upper - clist->vadjustment->page_size;
-
+
gtk_adjustment_set_value(clist->vadjustment, value);
}
horizontal_timeout (GtkCList *clist)
{
GdkEventMotion event = { 0 };
-
+
GDK_THREADS_ENTER ();
-
+
clist->htimer = 0;
-
+
event.type = GDK_MOTION_NOTIFY;
event.send_event = TRUE;
-
+
gtk_clist_motion (GTK_WIDGET (clist), &event);
-
+
GDK_THREADS_LEAVE ();
return FALSE;
vertical_timeout (GtkCList *clist)
{
GdkEventMotion event = { 0 };
-
+
GDK_THREADS_ENTER ();
-
+
clist->vtimer = 0;
-
+
event.type = GDK_MOTION_NOTIFY;
event.send_event = TRUE;
-
+
gtk_clist_motion (GTK_WIDGET (clist), &event);
-
+
GDK_THREADS_LEAVE ();
-
+
return FALSE;
}
if (gdk_pointer_is_grabbed ())
gdk_pointer_ungrab (GDK_CURRENT_TIME);
}
-
+
if (clist->htimer)
{
gtk_timeout_remove (clist->htimer);
clist->htimer = 0;
}
-
+
if (clist->vtimer)
{
gtk_timeout_remove (clist->vtimer);
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
- GTK_CLIST_CLASS_FW (clist)->sort_list (clist);
+
+ GTK_CLIST_GET_CLASS (clist)->sort_list (clist);
}
void
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
clist->compare = (cmp_func) ? cmp_func : default_compare;
}
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (column < 0 || column >= clist->columns)
return;
-
+
clist->sort_column = column;
}
{
char *text1 = NULL;
char *text2 = NULL;
-
+
GtkCListRow *row1 = (GtkCListRow *) ptr1;
GtkCListRow *row2 = (GtkCListRow *) ptr2;
-
+
switch (row1->cell[clist->sort_column].type)
{
case GTK_CELL_TEXT:
default:
break;
}
-
+
switch (row2->cell[clist->sort_column].type)
{
case GTK_CELL_TEXT:
default:
break;
}
-
+
if (!text2)
return (text1 != NULL);
-
+
if (!text1)
return -1;
-
+
return strcmp (text1, text2);
}
GList *list;
GList *work;
gint i;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (clist->rows <= 1)
return;
-
+
if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
return;
-
+
gtk_clist_freeze (clist);
-
+
if (clist->anchor != -1 && clist->selection_mode == GTK_SELECTION_EXTENDED)
{
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
clist->undo_selection = NULL;
clist->undo_unselection = NULL;
}
-
+
clist->row_list = gtk_clist_mergesort (clist, clist->row_list, clist->rows);
-
+
work = clist->selection;
-
+
for (i = 0, list = clist->row_list; i < clist->rows; i++, list = list->next)
{
if (GTK_CLIST_ROW (list)->state == GTK_STATE_SELECTED)
if (i == clist->rows - 1)
clist->row_list_end = list;
}
-
+
gtk_clist_thaw (clist);
}
GList z = { 0 }; /* auxiliary node */
GList *c;
gint cmp;
-
+
c = &z;
-
+
while (a || b)
{
if (a && !b)
}
}
}
-
+
return z.next;
}
{
GList *half;
gint i;
-
+
if (num == 1)
{
return list;
half = list;
for (i = 0; i < num / 2; i++)
half = half->next;
-
+
/* cut the list in two */
half->prev->next = NULL;
half->prev = NULL;
-
+
/* recursively sort both lists */
return gtk_clist_merge (clist,
- gtk_clist_mergesort (clist, list, num / 2),
- gtk_clist_mergesort (clist, half, num - num / 2));
+ gtk_clist_mergesort (clist, list, num / 2),
+ gtk_clist_mergesort (clist, half, num - num / 2));
}
}
drag_source_info_destroy (gpointer data)
{
GtkCListCellInfo *info = data;
-
+
g_free (info);
}
drag_dest_info_destroy (gpointer data)
{
GtkCListDestInfo *info = data;
-
+
g_free (info);
}
GtkCListDestInfo *dest_info)
{
GtkWidget *widget;
-
+
widget = GTK_WIDGET (clist);
-
+
dest_info->insert_pos = GTK_CLIST_DRAG_NONE;
-
+
y -= (GTK_CONTAINER (clist)->border_width +
widget->style->klass->ythickness +
clist->column_title_area.height);
-
+
dest_info->cell.row = ROW_FROM_YPIXEL (clist, y);
if (dest_info->cell.row >= clist->rows)
{
}
if (dest_info->cell.row < -1)
dest_info->cell.row = -1;
-
+
x -= GTK_CONTAINER (widget)->border_width + widget->style->klass->xthickness;
dest_info->cell.column = COLUMN_FROM_XPIXEL (clist, x);
-
+
if (dest_info->cell.row >= 0)
{
gint y_delta;
gint h = 0;
-
+
y_delta = y - ROW_TOP_YPIXEL (clist, dest_info->cell.row);
if (GTK_CLIST_DRAW_DRAG_RECT(clist))
dest_info->insert_pos = GTK_CLIST_DRAG_BEFORE;
h = clist->row_height / 2;
}
-
+
if (GTK_CLIST_DRAW_DRAG_LINE(clist))
{
if (y_delta < h)
{
GtkCList *clist;
GtkCListCellInfo *info;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CLIST (widget));
g_return_if_fail (context != NULL);
-
+
clist = GTK_CLIST (widget);
-
+
clist->drag_button = 0;
remove_grab (clist);
-
+
switch (clist->selection_mode)
{
case GTK_SELECTION_EXTENDED:
update_extended_selection (clist, clist->focus_row);
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
break;
case GTK_SELECTION_SINGLE:
case GTK_SELECTION_MULTIPLE:
case GTK_SELECTION_BROWSE:
break;
}
-
+
info = g_dataset_get_data (context, "gtk-clist-drag-source");
-
+
if (!info)
{
info = g_new (GtkCListCellInfo, 1);
-
+
if (clist->click_cell.row < 0)
clist->click_cell.row = 0;
else if (clist->click_cell.row >= clist->rows)
clist->click_cell.row = clist->rows - 1;
info->row = clist->click_cell.row;
info->column = clist->click_cell.column;
-
+
g_dataset_set_data_full (context, "gtk-clist-drag-source", info,
drag_source_info_destroy);
}
-
+
if (GTK_CLIST_USE_DRAG_ICONS (clist))
gtk_drag_set_icon_default (context);
}
GdkDragContext *context)
{
GtkCList *clist;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CLIST (widget));
g_return_if_fail (context != NULL);
-
+
clist = GTK_CLIST (widget);
-
+
clist->click_cell.row = -1;
clist->click_cell.column = -1;
}
{
GtkCList *clist;
GtkCListDestInfo *dest_info;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CLIST (widget));
g_return_if_fail (context != NULL);
-
+
clist = GTK_CLIST (widget);
-
+
dest_info = g_dataset_get_data (context, "gtk-clist-drag-dest");
if (dest_info)
{
GList *list;
GdkAtom atom = gdk_atom_intern ("gtk-clist-drag-reorder", FALSE);
-
+
list = context->targets;
while (list)
{
if (atom == GPOINTER_TO_INT (list->data))
{
- GTK_CLIST_CLASS_FW (clist)->draw_drag_highlight
+ GTK_CLIST_GET_CLASS (clist)->draw_drag_highlight
(clist,
g_list_nth (clist->row_list, dest_info->cell.row)->data,
dest_info->cell.row, dest_info->insert_pos);
GtkCList *clist;
GtkCListDestInfo new_info;
GtkCListDestInfo *dest_info;
-
+
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
-
+
clist = GTK_CLIST (widget);
-
+
dest_info = g_dataset_get_data (context, "gtk-clist-drag-dest");
-
+
if (!dest_info)
{
dest_info = g_new (GtkCListDestInfo, 1);
-
+
dest_info->insert_pos = GTK_CLIST_DRAG_NONE;
dest_info->cell.row = -1;
dest_info->cell.column = -1;
-
+
g_dataset_set_data_full (context, "gtk-clist-drag-dest", dest_info,
drag_dest_info_destroy);
}
-
+
drag_dest_cell (clist, x, y, &new_info);
-
+
if (GTK_CLIST_REORDERABLE (clist))
{
GList *list;
GdkAtom atom = gdk_atom_intern ("gtk-clist-drag-reorder", FALSE);
-
+
list = context->targets;
while (list)
{
break;
list = list->next;
}
-
+
if (list)
{
if (gtk_drag_get_source_widget (context) != widget ||
}
return TRUE;
}
-
+
if (new_info.cell.row != dest_info->cell.row ||
(new_info.cell.row == dest_info->cell.row &&
dest_info->insert_pos != new_info.insert_pos))
{
if (dest_info->cell.row >= 0)
- GTK_CLIST_CLASS_FW (clist)->draw_drag_highlight
+ GTK_CLIST_GET_CLASS (clist)->draw_drag_highlight
(clist, g_list_nth (clist->row_list,
dest_info->cell.row)->data,
dest_info->cell.row, dest_info->insert_pos);
-
+
dest_info->insert_pos = new_info.insert_pos;
dest_info->cell.row = new_info.cell.row;
dest_info->cell.column = new_info.cell.column;
- GTK_CLIST_CLASS_FW (clist)->draw_drag_highlight
+ GTK_CLIST_GET_CLASS (clist)->draw_drag_highlight
(clist, g_list_nth (clist->row_list,
dest_info->cell.row)->data,
dest_info->cell.row, dest_info->insert_pos);
-
+
gdk_drag_status (context, context->suggested_action, time);
}
return TRUE;
}
}
-
+
dest_info->insert_pos = new_info.insert_pos;
dest_info->cell.row = new_info.cell.row;
dest_info->cell.column = new_info.cell.column;
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
g_return_val_if_fail (context != NULL, FALSE);
-
+
if (GTK_CLIST_REORDERABLE (widget) &&
gtk_drag_get_source_widget (context) == widget)
{
GList *list;
GdkAtom atom = gdk_atom_intern ("gtk-clist-drag-reorder", FALSE);
-
+
list = context->targets;
while (list)
{
guint time)
{
GtkCList *clist;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CLIST (widget));
g_return_if_fail (context != NULL);
g_return_if_fail (selection_data != NULL);
-
+
clist = GTK_CLIST (widget);
-
+
if (GTK_CLIST_REORDERABLE (clist) &&
gtk_drag_get_source_widget (context) == widget &&
selection_data->target ==
selection_data->length == sizeof (GtkCListCellInfo))
{
GtkCListCellInfo *source_info;
-
+
source_info = (GtkCListCellInfo *)(selection_data->data);
if (source_info)
{
GtkCListDestInfo dest_info;
-
+
drag_dest_cell (clist, x, y, &dest_info);
-
+
if (dest_info.insert_pos == GTK_CLIST_DRAG_AFTER)
dest_info.cell.row++;
if (source_info->row < dest_info.cell.row)
dest_info.cell.row--;
if (dest_info.cell.row != source_info->row)
gtk_clist_row_move (clist, source_info->row, dest_info.cell.row);
-
+
g_dataset_remove_data (context, "gtk-clist-drag-dest");
}
}
g_return_if_fail (GTK_IS_CLIST (widget));
g_return_if_fail (context != NULL);
g_return_if_fail (selection_data != NULL);
-
+
if (selection_data->target ==
gdk_atom_intern ("gtk-clist-drag-reorder", FALSE))
{
GtkCListCellInfo *info;
-
+
info = g_dataset_get_data (context, "gtk-clist-drag-source");
-
+
if (info)
{
GtkCListCellInfo ret_info;
-
+
ret_info.row = info->row;
ret_info.column = info->column;
-
+
gtk_selection_data_set (selection_data, selection_data->target,
GTK_TYPE_POINTER, (guchar *) &ret_info,
sizeof (GtkCListCellInfo));
GtkCListDragPos drag_pos)
{
gint y;
-
+
y = ROW_TOP_YPIXEL (clist, dest_row_number) - 1;
-
+
switch (drag_pos)
{
case GTK_CLIST_DRAG_NONE:
gboolean reorderable)
{
GtkWidget *widget;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if ((GTK_CLIST_REORDERABLE(clist) != 0) == reorderable)
return;
-
+
widget = GTK_WIDGET (clist);
-
+
if (reorderable)
{
GTK_CLIST_SET_FLAG (clist, CLIST_REORDERABLE);
{
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CLIST (clist));
-
+
if (use_icons != 0)
GTK_CLIST_SET_FLAG (clist, CLIST_USE_DRAG_ICONS);
else
remove_grab (clist);
clist->drag_button = 0;
}
-
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
-
+
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
+
clist->button_actions[button] = button_actions;
}
}
- /* GTK - The GIMP Toolkit
+/* GTK - The GIMP Toolkit
* Copyright (C) 2000 Red Hat, Inc.
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
-#include <glib.h>
-#include "gdk/gdkx.h"
+#include "x11/gdkx.h"
#include "gdk/gdkkeysyms.h"
#include "gtkcolorsel.h"
#include "gtkhsv.h"
struct _ColorSelectionPrivate
{
- /* < Private > */
- gboolean use_opacity;
- gboolean use_palette;
- gboolean changing;
- gboolean default_set;
-
+ guint use_opacity : 1;
+ guint use_palette : 1;
+ guint changing : 1;
+ guint default_set : 1;
+
+ /* The color dropper */
+ guint moving_dropper : 1;
+
gdouble color[COLORSEL_NUM_CHANNELS];
gdouble old_color[COLORSEL_NUM_CHANNELS];
-
+
GtkWidget *triangle_colorsel;
GtkWidget *hue_spinbutton;
GtkWidget *sat_spinbutton;
GtkWidget *opacity_entry;
GtkWidget *palette_frame;
GtkWidget *hex_entry;
-
+
/* The Palette code */
- GtkWidget *custom_palette [CUSTOM_PALETTE_WIDTH][CUSTOM_PALETTE_HEIGHT];
+ GtkWidget *custom_palette [GTK_CUSTOM_PALETTE_WIDTH][GTK_CUSTOM_PALETTE_HEIGHT];
GtkWidget *last_palette;
-
+
/* The color_sample stuff */
GtkWidget *sample_area;
GtkWidget *old_sample;
GtkWidget *cur_sample;
GtkWidget *colorsel;
-
- /* The color dropper */
- gboolean moving_dropper;
};
-static void gtk_color_selection_init (GtkColorSelection *colorsel);
+static void gtk_color_selection_init (GtkColorSelection *colorsel);
static void gtk_color_selection_class_init (GtkColorSelectionClass *klass);
-static void gtk_color_selection_destroy (GtkObject *object);
-static void update_color (GtkColorSelection *colorsel);
+static void gtk_color_selection_destroy (GtkObject *object);
+static void update_color (GtkColorSelection *colorsel);
-static GtkVBoxClass *parent_class = NULL;
+static gpointer parent_class = NULL;
static guint color_selection_signals[LAST_SIGNAL] = { 0 };
gdouble *colsrc;
GdkColor bg;
gint n, i;
-
+
priv = colorsel->private;
window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_set_app_paintable (GTK_WIDGET (window), TRUE);
"gtk-color-selection-drag-window",
window,
(GtkDestroyNotify) gtk_widget_destroy);
-
+
if (widget == priv->old_sample)
colsrc = priv->old_color;
else
colsrc = priv->color;
-
+
for (i=0, n = COLORSEL_RED; n <= COLORSEL_BLUE; n++)
{
colors[i++] = colsrc[n];
}
-
+
if (priv->use_opacity)
{
colors[i] = colsrc[COLORSEL_OPACITY];
}
-
+
bg.red = 0xffff * colors[0];
bg.green = 0xffff * colors[1];
bg.blue = 0xffff * colors[2];
-
+
gdk_color_alloc (gtk_widget_get_colormap (window), &bg);
gdk_window_set_background (window->window, &bg);
-
+
gtk_drag_set_icon_widget (context, window, -2, -2);
}
guint16 *vals;
gdouble color[4];
priv = colorsel->private;
-
+
/* This is currently a guint16 array of the format:
* R
* G
* B
* opacity
*/
-
+
if (selection_data->length < 0)
return;
-
+
if ((selection_data->format != 16) ||
(selection_data->length != 8))
{
g_warning ("Received invalid color data\n");
return;
}
-
+
vals = (guint16 *)selection_data->data;
-
+
if (widget == priv->cur_sample)
{
color[0] = (gdouble)vals[0] / 0xffff;
color[1] = (gdouble)vals[1] / 0xffff;
color[2] = (gdouble)vals[2] / 0xffff;
color[3] = (gdouble)vals[3] / 0xffff;
-
+
gtk_color_selection_set_color (colorsel, color);
}
}
ColorSelectionPrivate *priv;
guint16 vals[4];
gdouble *colsrc;
-
+
priv = colorsel->private;
-
+
if (widget == priv->old_sample)
colsrc = priv->old_color;
else
colsrc = priv->color;
-
+
vals[0] = colsrc[COLORSEL_RED] * 0xffff;
vals[1] = colsrc[COLORSEL_GREEN] * 0xffff;
vals[2] = colsrc[COLORSEL_BLUE] * 0xffff;
vals[3] = priv->use_opacity ? colsrc[COLORSEL_OPACITY] * 0xffff : 0xffff;
-
+
gtk_selection_data_set (selection_data,
gdk_atom_intern ("application/x-color", FALSE),
16, (guchar *)vals, 8);
gdouble o;
guchar *buf;
ColorSelectionPrivate *priv;
-
+
g_return_if_fail (colorsel != NULL);
priv = colorsel->private;
-
+
g_return_if_fail (priv->sample_area != NULL);
if (!GTK_WIDGET_DRAWABLE (priv->sample_area))
return;
-
+
if (which == 0)
{
da = priv->old_sample;
c[n] = (guchar) (255.0 * priv->color[i]);
goff = priv->old_sample->allocation.width % 32;
}
-
+
wid = da->allocation.width;
heig = da->allocation.height;
-
+
buf = g_new(guchar, 3 * wid * heig);
-
+
#if 0
i = COLORSEL_RED;
for (n = 0; n < 3; n++)
c[n + 3] = (guchar) (255.0 * priv->color[i++]);
}
#endif
-
+
if (priv->use_opacity)
{
o = (which) ? priv->color[COLORSEL_OPACITY] : priv->old_color[COLORSEL_OPACITY];
-
+
for (n = 0; n < 3; n++)
{
cc[n] = (guchar) ((1.0 - o) * 192 + (o * (gdouble) c[n]));
}
cp = cc;
}
-
+
i = 0;
for (y = 0; y < heig; y++)
{
f = 3 * ((((goff + x) % 32) < 16) ^ ((y % 32) < 16));
else
f = 0;
-
+
for (n = 0; n < 3; n++)
buf[i++] = cp[n + f];
}
}
-
+
gdk_draw_rgb_image(da->window,
da->style->black_gc,
0, 0,
GDK_RGB_DITHER_NORMAL,
buf,
3*wid);
-
-
+
+
g_free (buf);
-
}
};
ColorSelectionPrivate *priv;
priv = colorsel->private;
-
+
gtk_drag_source_set (sample,
GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
targets, 1,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
-
+
gtk_signal_connect (GTK_OBJECT (sample),
"drag_begin",
GTK_SIGNAL_FUNC (color_sample_drag_begin),
colorsel);
if (sample == priv->cur_sample)
{
-
+
gtk_drag_dest_set (sample,
GTK_DEST_DEFAULT_HIGHLIGHT |
GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_DROP,
targets, 1,
GDK_ACTION_COPY);
-
+
gtk_signal_connect (GTK_OBJECT (sample),
"drag_end",
GTK_SIGNAL_FUNC (color_sample_drag_end),
colorsel);
}
-
+
gtk_signal_connect (GTK_OBJECT (sample),
"drag_data_get",
GTK_SIGNAL_FUNC (color_sample_drag_handle),
"drag_data_received",
GTK_SIGNAL_FUNC (color_sample_drop_handle),
colorsel);
-
+
}
color_sample_new (GtkColorSelection *colorsel)
{
ColorSelectionPrivate *priv;
-
+
priv = colorsel->private;
-
+
gtk_widget_push_visual(gdk_rgb_get_visual());
gtk_widget_push_colormap(gdk_rgb_get_cmap());
-
+
priv->sample_area = gtk_hbox_new (FALSE, 0);
priv->old_sample = gtk_drawing_area_new ();
priv->cur_sample = gtk_drawing_area_new ();
-
+
gtk_box_pack_start (GTK_BOX (priv->sample_area), priv->old_sample,
TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (priv->sample_area), priv->cur_sample,
TRUE, TRUE, 0);
gtk_widget_pop_visual();
gtk_widget_pop_colormap();
-
+
gtk_signal_connect(GTK_OBJECT (priv->old_sample), "expose_event",
GTK_SIGNAL_FUNC (color_old_sample_expose),
colorsel);
gtk_signal_connect(GTK_OBJECT (priv->cur_sample), "expose_event",
GTK_SIGNAL_FUNC (color_cur_sample_expose),
colorsel);
-
+
color_sample_setup_dnd (colorsel, priv->old_sample);
color_sample_setup_dnd (colorsel, priv->cur_sample);
-
+
gtk_widget_show_all (priv->sample_area);
}
-static void
-color_sample_set_use_opacity (GtkColorSelection *colorsel)
-{
- ColorSelectionPrivate *priv;
-
- g_return_if_fail (colorsel != NULL);
-
- priv = colorsel->private;
-
- color_sample_draw_samples (colorsel);
-}
-
/*
*
palette_get_color (GtkWidget *drawing_area, gdouble *color)
{
gdouble *color_val;
-
+
g_return_if_fail (color != NULL);
-
+
color_val = gtk_object_get_data (GTK_OBJECT (drawing_area), "color_val");
if (color_val == NULL)
{
color[3] = 1.0;
return;
}
-
+
color[0] = color_val[0];
color[1] = color_val[1];
color[2] = color_val[2];
#define INTENSITY(r, g, b) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11)
static void
-palette_paint (GtkWidget *drawing_area, GdkRectangle *area, gpointer data)
+palette_paint (GtkWidget *drawing_area,
+ GdkRectangle *area,
+ gpointer data)
{
if (drawing_area->window == NULL)
return;
-
+
gdk_window_clear_area (drawing_area->window,
area->x,
area->y,
area->width,
area->height);
-
+
if (GTK_WIDGET_HAS_FOCUS (drawing_area))
{
GdkGC *gc;
gdouble color[4];
-
+
palette_get_color (drawing_area, color);
-
+
if (INTENSITY (color[0], color[1], color[2]) > 0.5)
gc = drawing_area->style->black_gc;
else
gc = drawing_area->style->white_gc;
-
+
gdk_draw_rectangle (drawing_area->window,
gc, FALSE, 0, 0,
drawing_area->allocation.width - 1,
}
static void
-palette_expose (GtkWidget *drawing_area, GdkEventExpose *event, gpointer data)
+palette_expose (GtkWidget *drawing_area,
+ GdkEventExpose *event,
+ gpointer data)
{
if (drawing_area->window == NULL)
return;
-
+
palette_paint (drawing_area, &(event->area), data);
}
static void
-palette_focus_in (GtkWidget *drawing_area, GdkEventFocus *event, gpointer data)
+palette_focus_in (GtkWidget *drawing_area,
+ GdkEventFocus *event,
+ gpointer data)
{
ColorSelectionPrivate *priv;
-
+
if (drawing_area->window == NULL)
return;
-
+
priv = GTK_COLOR_SELECTION (data)->private;
priv->last_palette = drawing_area;
GTK_WIDGET_SET_FLAGS (drawing_area, GTK_HAS_FOCUS);
}
static void
-palette_focus_out (GtkWidget *drawing_area, GdkEventFocus *event, gpointer data)
+palette_focus_out (GtkWidget *drawing_area,
+ GdkEventFocus *event,
+ gpointer data)
{
GTK_WIDGET_UNSET_FLAGS (drawing_area, GTK_HAS_FOCUS);
gtk_widget_queue_clear_area (drawing_area, 0, 0, drawing_area->allocation.x, drawing_area->allocation.y);
}
static void
-palette_press (GtkWidget *drawing_area, GdkEventButton *event, gpointer data)
+palette_press (GtkWidget *drawing_area,
+ GdkEventButton *event,
+ gpointer data)
{
gtk_widget_grab_focus (drawing_area);
if (GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (drawing_area), "color_set")) != 0)
}
static void
-palette_draw (GtkWidget *drawing_area, GdkRectangle *area, gpointer data)
+palette_draw (GtkWidget *drawing_area,
+ GdkRectangle *area,
+ gpointer data)
{
palette_paint (drawing_area, area, data);
}
{
if (GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (drawing_area), "color_set")) == 0)
return;
-
+
gtk_widget_reset_rc_styles (drawing_area);
gtk_object_set_data (GTK_OBJECT (drawing_area), "color_set", GINT_TO_POINTER (0));
}
GtkWidget *window;
gdouble colors[4];
GdkColor bg;
-
+
priv = colorsel->private;
window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_set_app_paintable (GTK_WIDGET (window), TRUE);
"gtk-color-selection-drag-window",
window,
(GtkDestroyNotify) gtk_widget_destroy);
-
+
palette_get_color (widget, colors);
bg.red = 0xffff * colors[0];
bg.green = 0xffff * colors[1];
bg.blue = 0xffff * colors[2];
-
+
gdk_color_alloc (gtk_widget_get_colormap (window), &bg);
gdk_window_set_background (window->window, &bg);
-
+
gtk_drag_set_icon_widget (context, window, -2, -2);
}
{
guint16 vals[4];
gdouble colsrc[4];
-
+
palette_get_color (widget, colsrc);
-
+
vals[0] = colsrc[COLORSEL_RED] * 0xffff;
vals[1] = colsrc[COLORSEL_GREEN] * 0xffff;
vals[2] = colsrc[COLORSEL_BLUE] * 0xffff;
vals[3] = 0xffff;
-
+
gtk_selection_data_set (selection_data,
gdk_atom_intern ("application/x-color", FALSE),
16, (guchar *)vals, 8);
}
static void
-palette_set_color (GtkWidget *drawing_area, GtkColorSelection *colorsel, gdouble *color)
+palette_set_color (GtkWidget *drawing_area,
+ GtkColorSelection *colorsel,
+ gdouble *color)
{
GtkRcStyle *rc_style;
gdouble *new_color = g_new (double, 4);
gdouble *old_color;
-
+
rc_style = gtk_rc_style_new ();
rc_style->bg[GTK_STATE_NORMAL].red = color[0]*65535;
rc_style->bg[GTK_STATE_NORMAL].green = color[1]*65535;
rc_style->color_flags[GTK_STATE_NORMAL] = GTK_RC_BG;
gtk_rc_style_ref (rc_style);
gtk_widget_modify_style (drawing_area, rc_style);
-
+
if (GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (drawing_area), "color_set")) == 0)
{
static const GtkTargetEntry targets[] = {
GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
targets, 1,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
-
+
gtk_signal_connect (GTK_OBJECT (drawing_area),
"drag_begin",
GTK_SIGNAL_FUNC (palette_drag_begin),
"drag_data_get",
GTK_SIGNAL_FUNC (palette_drag_handle),
colorsel);
-
+
gtk_object_set_data (GTK_OBJECT (drawing_area), "color_set", GINT_TO_POINTER (1));
}
else
new_color[1] = color[1];
new_color[2] = color[2];
new_color[3] = 1.0;
-
+
gtk_object_set_data (GTK_OBJECT (drawing_area), "color_val", new_color);
}
{
guint16 *vals;
gdouble color[4];
-
+
if (selection_data->length < 0)
return;
-
+
if ((selection_data->format != 16) ||
(selection_data->length != 8))
{
g_warning ("Received invalid color data\n");
return;
}
-
+
vals = (guint16 *)selection_data->data;
-
+
color[0] = (gdouble)vals[0] / 0xffff;
color[1] = (gdouble)vals[1] / 0xffff;
color[2] = (gdouble)vals[2] / 0xffff;
gtk_color_selection_set_color (GTK_COLOR_SELECTION (data), color);
}
-static int
-palette_activate (GtkWidget *widget,
- GdkEventKey *event,
- gpointer data)
+static gint
+palette_activate (GtkWidget *widget,
+ GdkEventKey *event,
+ gpointer data)
{
GtkColorSelection *colorsel = data;
ColorSelectionPrivate *priv;
-
+
if ((event->keyval == ' ') || (event->keyval == GDK_Return))
{
priv = colorsel->private;
palette_set_color (widget, GTK_COLOR_SELECTION (data), priv->color);
}
-
+
return TRUE;
}
-static GtkWidget *
+static GtkWidget*
palette_new (GtkColorSelection *colorsel)
{
GtkWidget *retval;
static const GtkTargetEntry targets[] = {
{ "application/x-color", 0 }
};
-
+
retval = gtk_drawing_area_new ();
gtk_object_set_data (GTK_OBJECT (retval), "color_set", GINT_TO_POINTER (0));
gtk_widget_set_events (retval, GDK_BUTTON_PRESS_MASK | GDK_EXPOSURE_MASK);
-
+
GTK_WIDGET_SET_FLAGS (retval, GTK_CAN_FOCUS);
gtk_signal_connect (GTK_OBJECT (retval), "focus_in_event", palette_focus_in, colorsel);
gtk_signal_connect (GTK_OBJECT (retval), "focus_out_event", palette_focus_out, colorsel);
gtk_signal_connect (GTK_OBJECT (retval), "draw", palette_draw, colorsel);
gtk_signal_connect (GTK_OBJECT (retval), "expose_event", palette_expose, colorsel);
gtk_signal_connect (GTK_OBJECT (retval), "button_press_event", palette_press, colorsel);
-
+
gtk_drag_dest_set (retval,
GTK_DEST_DEFAULT_HIGHLIGHT |
GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_DROP,
targets, 1,
GDK_ACTION_COPY);
-
+
gtk_signal_connect (GTK_OBJECT (retval), "drag_end", palette_drag_end, NULL);
gtk_signal_connect (GTK_OBJECT (retval), "drag_data_received", palette_drop_handle, colorsel);
gtk_signal_connect (GTK_OBJECT (retval), "key_press_event", GTK_SIGNAL_FUNC (palette_activate), colorsel);
-
+
return retval;
}
*/
static void
-initialize_cursor ()
+initialize_cursor (void)
{
GdkColor fg, bg;
-
+
GdkPixmap *pixmap =
gdk_bitmap_create_from_data (NULL,
dropper_bits,
gdk_bitmap_create_from_data (NULL,
dropper_mask,
DROPPER_WIDTH, DROPPER_HEIGHT);
-
+
gdk_color_white (gdk_colormap_get_system (), &bg);
gdk_color_black (gdk_colormap_get_system (), &fg);
-
+
picker_cursor = gdk_cursor_new_from_pixmap (pixmap, mask, &fg, &bg, DROPPER_X_HOT ,DROPPER_Y_HOT);
-
+
gdk_pixmap_unref (pixmap);
gdk_pixmap_unref (mask);
-
+
}
static void
-grab_color_at_mouse (GtkWidget *button, int x_root, int y_root, gpointer data)
+grab_color_at_mouse (GtkWidget *button,
+ gint x_root,
+ gint y_root,
+ gpointer data)
{
GdkImage *image;
guint32 pixel;
ColorSelectionPrivate *priv;
GdkColormap *colormap = gdk_colormap_get_system ();
XColor xcolor;
-
+
priv = colorsel->private;
-
+
image = gdk_image_get (GDK_ROOT_PARENT (), x_root, y_root, 1, 1);
pixel = gdk_image_get_pixel (image, 0, 0);
visual = gdk_colormap_get_visual (colormap);
-
+
switch (visual->type) {
case GDK_VISUAL_DIRECT_COLOR:
case GDK_VISUAL_TRUE_COLOR:
g_assert_not_reached ();
break;
}
-
+
gtk_rgb_to_hsv (priv->color[COLORSEL_RED],
priv->color[COLORSEL_GREEN],
priv->color[COLORSEL_BLUE],
}
static void
-mouse_motion (GtkWidget *button, GdkEventMotion *event, gpointer data)
+mouse_motion (GtkWidget *button,
+ GdkEventMotion *event,
+ gpointer data)
{
grab_color_at_mouse (button, event->x_root, event->y_root, data);
}
static void
-mouse_release (GtkWidget *button, GdkEventButton *event, gpointer data)
+mouse_release (GtkWidget *button,
+ GdkEventButton *event,
+ gpointer data)
{
GtkColorSelection *colorsel = data;
ColorSelectionPrivate *priv;
priv = colorsel->private;
-
+
gtk_signal_disconnect_by_func (GTK_OBJECT (button), mouse_motion, data);
gtk_signal_disconnect_by_func (GTK_OBJECT (button), mouse_release, data);
-
+
grab_color_at_mouse (button, event->x_root, event->y_root, data);
gdk_pointer_ungrab (0);
}
/* Helper Functions */
static void
-mouse_press (GtkWidget *button, GdkEventButton *event, gpointer data)
+mouse_press (GtkWidget *button,
+ GdkEventButton *event,
+ gpointer data)
{
GtkColorSelection *colorsel = data;
ColorSelectionPrivate *priv;
priv = colorsel->private;
-
+
gtk_signal_connect (GTK_OBJECT (button), "motion_notify_event", mouse_motion, data);
gtk_signal_connect (GTK_OBJECT (button), "button_release_event", mouse_release, data);
gtk_signal_disconnect_by_func (GTK_OBJECT (button), mouse_press, data);
{
GtkColorSelection *colorsel = gtk_object_get_data (GTK_OBJECT (button), "COLORSEL");
ColorSelectionPrivate *priv = colorsel->private;
-
+
if (picker_cursor == NULL)
{
initialize_cursor ();
}
-
+
/* Why do we do this? Because the "clicked" signal will be emitted after the "button_released"
signal. We don't want to do this stuff again, though, or else it will get trapped here. So,
priv->moving_dropper is initialized to FALSE at the initialization of the colorselector,
{
priv->moving_dropper = TRUE;
gtk_signal_connect (GTK_OBJECT (button), "button_press_event", mouse_press, colorsel);
-
+
gdk_pointer_grab (button->window,
FALSE,
GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK,
}
void
-hex_changed (GtkWidget *hex_entry, gpointer data)
+hex_changed (GtkWidget *hex_entry,
+ gpointer data)
{
GtkColorSelection *colorsel;
ColorSelectionPrivate *priv;
GdkColor color;
gchar *text;
-
+
colorsel = GTK_COLOR_SELECTION (data);
priv = colorsel->private;
-
+
if (priv->changing)
return;
-
+
text = gtk_editable_get_chars (GTK_EDITABLE (priv->hex_entry), 0, -1);
if (gdk_color_parse (text, &color))
{
}
void
-hsv_changed (GtkWidget *hsv, gpointer data)
+hsv_changed (GtkWidget *hsv,
+ gpointer data)
{
GtkColorSelection *colorsel;
ColorSelectionPrivate *priv;
-
+
colorsel = GTK_COLOR_SELECTION (data);
priv = colorsel->private;
-
+
if (priv->changing)
return;
-
+
gtk_hsv_get_color (GTK_HSV (hsv),
&priv->color[COLORSEL_HUE],
&priv->color[COLORSEL_SATURATION],
}
void
-adjustment_changed (GtkAdjustment *adjustment, gpointer data)
+adjustment_changed (GtkAdjustment *adjustment,
+ gpointer data)
{
GtkColorSelection *colorsel;
ColorSelectionPrivate *priv;
-
+
colorsel = GTK_COLOR_SELECTION (gtk_object_get_data (GTK_OBJECT (adjustment), "COLORSEL"));
priv = colorsel->private;
-
+
if (priv->changing)
return;
-
+
switch (GPOINTER_TO_INT (data))
{
case COLORSEL_SATURATION:
case COLORSEL_GREEN:
case COLORSEL_BLUE:
priv->color[GPOINTER_TO_INT (data)] = adjustment->value / 255;
-
+
gtk_rgb_to_hsv (priv->color[COLORSEL_RED],
priv->color[COLORSEL_GREEN],
priv->color[COLORSEL_BLUE],
}
void
-opacity_entry_changed (GtkWidget *opacity_entry, gpointer data)
+opacity_entry_changed (GtkWidget *opacity_entry,
+ gpointer data)
{
GtkColorSelection *colorsel;
ColorSelectionPrivate *priv;
GtkAdjustment *adj;
gchar *text;
-
+
colorsel = GTK_COLOR_SELECTION (data);
priv = colorsel->private;
if (priv->changing)
return;
-
+
text = gtk_editable_get_chars (GTK_EDITABLE (priv->opacity_entry), 0, -1);
adj = gtk_range_get_adjustment (GTK_RANGE (priv->opacity_slider));
gtk_adjustment_set_value (adj, g_strtod (text, NULL));
-
+
update_color (colorsel);
-
+
g_free (text);
}
static void
-widget_focus_in (GtkWidget *drawing_area, GdkEventFocus *event, gpointer data)
- /* This signal is connected to by all of the widgets except the "Set Color" button */
- /* This will let you add a color to the currently selected palette */
+widget_focus_in (GtkWidget *drawing_area,
+ GdkEventFocus *event,
+ gpointer data)
{
GtkColorSelection *colorsel = GTK_COLOR_SELECTION (data);
- ColorSelectionPrivate *priv;
-
- priv = colorsel->private;
-
+ ColorSelectionPrivate *priv = colorsel->private;
+
+ /* This signal is connected to by all of the widgets except the "Set Color" button
+ * This will let you add a color to the currently selected palette
+ */
+
priv->last_palette = NULL;
}
static void
make_label_spinbutton (GtkColorSelection *colorsel,
- GtkWidget **spinbutton,
- gchar *text,
- GtkWidget *table,
- gint i, gint j,
- gint channel_type)
+ GtkWidget **spinbutton,
+ gchar *text,
+ GtkWidget *table,
+ gint i,
+ gint j,
+ gint channel_type)
{
GtkWidget *label;
GtkAdjustment *adjust;
-
+
if (channel_type == COLORSEL_HUE)
{
adjust = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 360.0, 1.0, 1.0, 1.0));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, i, i+1, j, j+1);
gtk_table_attach_defaults (GTK_TABLE (table), *spinbutton, i+1, i+2, j, j+1);
-
+
}
static void
-make_palette_frame (GtkColorSelection *colorsel, GtkWidget *table, gint i, gint j)
+make_palette_frame (GtkColorSelection *colorsel,
+ GtkWidget *table,
+ gint i,
+ gint j)
{
GtkWidget *frame;
ColorSelectionPrivate *priv;
-
+
priv = colorsel->private;
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gchar entryval[12];
gchar opacity_text[32];
gchar *ptr;
+
priv->changing = TRUE;
color_sample_draw_samples (colorsel);
-
+
gtk_hsv_set_color (GTK_HSV (priv->triangle_colorsel),
priv->color[COLORSEL_HUE],
priv->color[COLORSEL_SATURATION],
gtk_adjustment_set_value (gtk_range_get_adjustment
(GTK_RANGE (priv->opacity_slider)),
priv->color[COLORSEL_OPACITY] * 255);
-
+
g_snprintf (opacity_text, 32, "%.0f", priv->color[COLORSEL_OPACITY] * 255);
gtk_entry_set_text (GTK_ENTRY (priv->opacity_entry), opacity_text);
-
+
g_snprintf (entryval, 11, "#%2X%2X%2X",
(guint) (255 * priv->color[COLORSEL_RED]),
(guint) (255 * priv->color[COLORSEL_GREEN]),
(guint) (255 * priv->color[COLORSEL_BLUE]));
-
+
for (ptr = entryval; *ptr; ptr++)
if (*ptr == ' ')
*ptr = '0';
}
static void
-add_button_pressed (GtkWidget *button, GtkColorSelection *colorsel)
+add_button_pressed (GtkWidget *button,
+ GtkColorSelection *colorsel)
{
- gint i, j;
ColorSelectionPrivate *priv;
-
+ gint i, j;
+
priv = colorsel->private;
-
- for (j = 0; j < CUSTOM_PALETTE_HEIGHT; j++)
+
+ for (j = 0; j < GTK_CUSTOM_PALETTE_HEIGHT; j++)
{
- for (i = 0; i < CUSTOM_PALETTE_WIDTH; i++)
+ for (i = 0; i < GTK_CUSTOM_PALETTE_WIDTH; i++)
{
/* Either last_palette is set and we're on it, or it's an empty palette */
if ((priv->last_palette && priv->last_palette == priv->custom_palette[i][j]) ||
- ((priv->last_palette == NULL) && (GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (priv->custom_palette[i][j]),
- "color_set")) == 0)))
+ ((priv->last_palette == NULL) &&
+ (GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (priv->custom_palette[i][j]),
+ "color_set")) == 0)))
{
palette_set_color (priv->custom_palette[i][j], colorsel, priv->color);
+
/* forward the selection */
- if ((i == CUSTOM_PALETTE_WIDTH - 1) && (j == CUSTOM_PALETTE_HEIGHT - 1))
+ if ((i == GTK_CUSTOM_PALETTE_WIDTH - 1) && (j == GTK_CUSTOM_PALETTE_HEIGHT - 1))
gtk_widget_grab_focus (priv->custom_palette[0][0]);
- else if (i == CUSTOM_PALETTE_WIDTH - 1)
+ else if (i == GTK_CUSTOM_PALETTE_WIDTH - 1)
gtk_widget_grab_focus (priv->custom_palette[0][j + 1]);
else
gtk_widget_grab_focus (priv->custom_palette[i + 1][j]);
+
return;
}
}
}
+
/* the palette is totally full. Add to the first one totally arbitrarily */
palette_set_color (priv->custom_palette[0][0], colorsel, priv->color);
+
/* forward the selection */
gtk_widget_grab_focus (priv->custom_palette[1][0]);
}
gtk_color_selection_get_type (void)
{
static GtkType color_selection_type = 0;
-
+
if (!color_selection_type)
{
static const GtkTypeInfo color_selection_info =
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
-
- color_selection_type = gtk_type_unique (gtk_vbox_get_type (), &color_selection_info);
+
+ color_selection_type = gtk_type_unique (GTK_TYPE_VBOX, &color_selection_info);
}
-
+
return color_selection_type;
}
gtk_color_selection_class_init (GtkColorSelectionClass *klass)
{
GtkObjectClass *object_class;
-
+
object_class = (GtkObjectClass*) klass;
-
- parent_class = gtk_type_class (gtk_vbox_get_type ());
-
+
+ parent_class = gtk_type_class (GTK_TYPE_VBOX);
+
color_selection_signals[COLOR_CHANGED] =
gtk_signal_new ("color_changed",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkColorSelectionClass, color_changed),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
-
-
+
+
gtk_object_class_add_signals (object_class, color_selection_signals, LAST_SIGNAL);
-
+
object_class->destroy = gtk_color_selection_destroy;
}
GdkBitmap *mask = NULL;
gint i, j;
ColorSelectionPrivate *priv;
-
- priv = colorsel->private = g_new (ColorSelectionPrivate, 1);
+
+ priv = colorsel->private = g_new0 (ColorSelectionPrivate, 1);
priv->changing = FALSE;
priv->default_set = FALSE;
priv->last_palette = NULL;
priv->moving_dropper = FALSE;
-
+
gtk_box_set_spacing (GTK_BOX (colorsel), 4);
top_hbox = gtk_hbox_new (FALSE, 8);
gtk_box_pack_start (GTK_BOX (colorsel), top_hbox, FALSE, FALSE, 0);
-
+
vbox = gtk_vbox_new (FALSE, 4);
priv->triangle_colorsel = gtk_hsv_new ();
gtk_signal_connect (GTK_OBJECT (priv->triangle_colorsel), "changed", hsv_changed, colorsel);
gtk_hsv_set_metrics (GTK_HSV (priv->triangle_colorsel), 174, 15);
gtk_box_pack_start (GTK_BOX (top_hbox), vbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), priv->triangle_colorsel, FALSE, FALSE, 0);
-
+
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
-
+
frame = gtk_frame_new (NULL);
gtk_widget_set_usize (frame, -1, 30);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
color_sample_new (colorsel);
gtk_container_add (GTK_CONTAINER (frame), priv->sample_area);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
-
+
button = gtk_button_new ();
gtk_signal_connect (GTK_OBJECT (button), "focus_in_event", widget_focus_in, colorsel);
- gtk_widget_set_events (button, GDK_POINTER_MOTION_MASK
- | GDK_POINTER_MOTION_HINT_MASK);
+ gtk_widget_set_events (button, GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
gtk_object_set_data (GTK_OBJECT (button), "COLORSEL", colorsel);
gtk_signal_connect (GTK_OBJECT (button), "clicked", get_screen_color, NULL);
dropper_pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL, gtk_widget_get_colormap (button), &mask, NULL, picker);
dropper_image = gtk_pixmap_new (dropper_pixmap, mask);
gtk_container_add (GTK_CONTAINER (button), dropper_image);
- label = gtk_label_new (_("Color Picker"));
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
-
+
top_right_vbox = gtk_vbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (top_hbox), top_right_vbox, FALSE, FALSE, 0);
table = gtk_table_new (8, 6, FALSE);
gtk_box_pack_start (GTK_BOX (top_right_vbox), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
-
+
make_label_spinbutton (colorsel, &priv->hue_spinbutton, _("Hue:"), table, 0, 0, COLORSEL_HUE);
make_label_spinbutton (colorsel, &priv->sat_spinbutton, _("Saturation:"), table, 0, 1, COLORSEL_SATURATION);
make_label_spinbutton (colorsel, &priv->val_spinbutton, _("Value:"), table, 0, 2, COLORSEL_VALUE);
make_label_spinbutton (colorsel, &priv->green_spinbutton, _("Green:"), table, 6, 1, COLORSEL_GREEN);
make_label_spinbutton (colorsel, &priv->blue_spinbutton, _("Blue:"), table, 6, 2, COLORSEL_BLUE);
gtk_table_attach_defaults (GTK_TABLE (table), gtk_hseparator_new (), 0, 8, 3, 4);
-
+
priv->opacity_label = gtk_label_new (_("Opacity:"));
gtk_misc_set_alignment (GTK_MISC (priv->opacity_label), 1.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), priv->opacity_label, 0, 1, 4, 5);
gtk_signal_connect (GTK_OBJECT (priv->opacity_entry), "focus_in_event", widget_focus_in, colorsel);
gtk_signal_connect (GTK_OBJECT (priv->opacity_entry), "activate", opacity_entry_changed, colorsel);
gtk_table_attach_defaults (GTK_TABLE (table), priv->opacity_entry, 7, 8, 4, 5);
-
+
label = gtk_label_new (_("Hex Value:"));
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 5, 6);
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_widget_set_usize (priv->hex_entry, 75, -1);
gtk_table_set_col_spacing (GTK_TABLE (table), 3, 25);
gtk_table_attach_defaults (GTK_TABLE (table), priv->hex_entry, 1, 5, 5, 6);
-
+
/* Set up the palette */
- table = gtk_table_new (CUSTOM_PALETTE_HEIGHT, CUSTOM_PALETTE_WIDTH, TRUE);
+ table = gtk_table_new (GTK_CUSTOM_PALETTE_HEIGHT, GTK_CUSTOM_PALETTE_WIDTH, TRUE);
gtk_table_set_row_spacings (GTK_TABLE (table), 1);
gtk_table_set_col_spacings (GTK_TABLE (table), 1);
- for (i = 0; i < CUSTOM_PALETTE_WIDTH; i++)
+ for (i = 0; i < GTK_CUSTOM_PALETTE_WIDTH; i++)
{
- for (j = 0; j < CUSTOM_PALETTE_HEIGHT; j++)
+ for (j = 0; j < GTK_CUSTOM_PALETTE_HEIGHT; j++)
{
make_palette_frame (colorsel, table, i, j);
}
gtk_signal_connect (GTK_OBJECT (button), "clicked", add_button_pressed, colorsel);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
-
+
gtk_widget_show_all (top_hbox);
-
+
if (priv->use_opacity == FALSE)
{
gtk_widget_hide (priv->opacity_label);
gtk_widget_hide (priv->opacity_slider);
gtk_widget_hide (priv->opacity_entry);
}
-
+
if (priv->use_palette == FALSE)
{
gtk_widget_hide (priv->palette_frame);
static void
gtk_color_selection_destroy (GtkObject *object)
{
- g_free (GTK_COLOR_SELECTION (object)->private);
+ GtkColorSelection *cselection = GTK_COLOR_SELECTION (object);
+
+ if (cselection->private)
+ {
+ g_free (cselection->private);
+ cselection->private = NULL;
+ }
+
+ GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
color[1] = 1.0;
color[2] = 1.0;
color[3] = 1.0;
-
+
colorsel = gtk_type_new (GTK_TYPE_COLOR_SELECTION);
priv = colorsel->private;
gtk_color_selection_set_color (colorsel, color);
gtk_color_selection_set_use_opacity (colorsel, FALSE);
-
+
/* We want to make sure that default_set is FALSE */
/* This way the user can still set it */
priv->default_set = FALSE;
-
+
return GTK_WIDGET (colorsel);
}
void
-gtk_color_selection_set_update_policy (GtkColorSelection *colorsel,
- GtkUpdateType policy)
+gtk_color_selection_set_update_policy (GtkColorSelection *colorsel,
+ GtkUpdateType policy)
{
g_return_if_fail (colorsel != NULL);
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
/* */
- g_warning ("This function is deprecated.");
+ g_warning (G_STRLOC ": This function is deprecated.");
}
/**
* Return value: TRUE if the @colorsel uses opacity. FALSE if it does't.
**/
gboolean
-gtk_color_selection_get_use_opacity (GtkColorSelection *colorsel)
+gtk_color_selection_get_use_opacity (GtkColorSelection *colorsel)
{
ColorSelectionPrivate *priv;
+
g_return_val_if_fail (colorsel != NULL, FALSE);
g_return_val_if_fail (GTK_IS_COLOR_SELECTION (colorsel), FALSE);
-
+
priv = colorsel->private;
+
return priv->use_opacity;
}
*
**/
void
-gtk_color_selection_set_use_opacity (GtkColorSelection *colorsel,
- gboolean use_opacity)
+gtk_color_selection_set_use_opacity (GtkColorSelection *colorsel,
+ gboolean use_opacity)
{
ColorSelectionPrivate *priv;
+
g_return_if_fail (colorsel != NULL);
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
-
+
priv = colorsel->private;
- if (priv->use_opacity == use_opacity)
- return;
-
- priv->use_opacity = use_opacity;
- if (use_opacity)
- {
- gtk_widget_show (priv->opacity_slider);
- gtk_widget_show (priv->opacity_label);
- gtk_widget_show (priv->opacity_entry);
- }
- else
+ use_opacity = use_opacity != FALSE;
+
+ if (priv->use_opacity != use_opacity)
{
- gtk_widget_hide (priv->opacity_slider);
- gtk_widget_hide (priv->opacity_label);
- gtk_widget_hide (priv->opacity_entry);
+ priv->use_opacity = use_opacity;
+ if (use_opacity)
+ {
+ gtk_widget_show (priv->opacity_slider);
+ gtk_widget_show (priv->opacity_label);
+ gtk_widget_show (priv->opacity_entry);
+ }
+ else
+ {
+ gtk_widget_hide (priv->opacity_slider);
+ gtk_widget_hide (priv->opacity_label);
+ gtk_widget_hide (priv->opacity_entry);
+ }
+ color_sample_draw_samples (colorsel);
}
- color_sample_set_use_opacity (colorsel);
}
/**
* Return value: TRUE if the palette is used. FALSE if it isn't.
**/
gboolean
-gtk_color_selection_get_use_palette (GtkColorSelection *colorsel)
+gtk_color_selection_get_use_palette (GtkColorSelection *colorsel)
{
ColorSelectionPrivate *priv;
- g_return_val_if_fail (colorsel != NULL, FALSE);
+
g_return_val_if_fail (GTK_IS_COLOR_SELECTION (colorsel), FALSE);
-
+
priv = colorsel->private;
+
return priv->use_palette;
}
*
**/
void
-gtk_color_selection_set_use_palette (GtkColorSelection *colorsel,
- gboolean use_palette)
+gtk_color_selection_set_use_palette (GtkColorSelection *colorsel,
+ gboolean use_palette)
{
ColorSelectionPrivate *priv;
g_return_if_fail (colorsel != NULL);
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
-
+
priv = colorsel->private;
- if (priv->use_palette == use_palette)
- return;
-
- priv->use_palette = use_palette;
- if (use_palette)
- gtk_widget_show (priv->palette_frame);
- else
- gtk_widget_hide (priv->palette_frame);
+ use_palette = use_palette != FALSE;
+
+ if (priv->use_palette != use_palette)
+ {
+ priv->use_palette = use_palette;
+ if (use_palette)
+ gtk_widget_show (priv->palette_frame);
+ else
+ gtk_widget_hide (priv->palette_frame);
+ }
}
/**
*
**/
void
-gtk_color_selection_set_color (GtkColorSelection *colorsel,
- gdouble *color)
+gtk_color_selection_set_color (GtkColorSelection *colorsel,
+ gdouble *color)
{
ColorSelectionPrivate *priv;
gint i;
-
+
g_return_if_fail (colorsel != NULL);
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
-
+
priv = colorsel->private;
priv->changing = TRUE;
priv->color[COLORSEL_RED] = color[0];
*
**/
void
-gtk_color_selection_get_color (GtkColorSelection *colorsel,
- gdouble *color)
+gtk_color_selection_get_color (GtkColorSelection *colorsel,
+ gdouble *color)
{
ColorSelectionPrivate *priv;
-
+
g_return_if_fail (colorsel != NULL);
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
-
+
priv = colorsel->private;
color[0] = priv->color[COLORSEL_RED];
color[1] = priv->color[COLORSEL_GREEN];
*
**/
void
-gtk_color_selection_set_old_color (GtkColorSelection *colorsel,
- gdouble *color)
+gtk_color_selection_set_old_color (GtkColorSelection *colorsel,
+ gdouble *color)
{
ColorSelectionPrivate *priv;
-
+
g_return_if_fail (colorsel != NULL);
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
-
+
priv = colorsel->private;
priv->changing = TRUE;
priv->old_color[COLORSEL_RED] = color[0];
*
**/
void
-gtk_color_selection_get_old_color (GtkColorSelection *colorsel,
- gdouble *color)
+gtk_color_selection_get_old_color (GtkColorSelection *colorsel,
+ gdouble *color)
{
ColorSelectionPrivate *priv;
-
+
g_return_if_fail (colorsel != NULL);
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
-
+
priv = colorsel->private;
color[0] = priv->old_color[COLORSEL_RED];
color[1] = priv->old_color[COLORSEL_GREEN];
**/
void
gtk_color_selection_set_palette_color (GtkColorSelection *colorsel,
- gint x,
- gint y,
- gdouble *color)
+ gint x,
+ gint y,
+ gdouble *color)
{
ColorSelectionPrivate *priv;
-
+
g_return_if_fail (colorsel != NULL);
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
- g_return_if_fail (x >= 0 && y >= 0 && x < CUSTOM_PALETTE_WIDTH && y < CUSTOM_PALETTE_HEIGHT);
-
+ g_return_if_fail (x >= 0 && y >= 0 && x < GTK_CUSTOM_PALETTE_WIDTH && y < GTK_CUSTOM_PALETTE_HEIGHT);
+
priv = colorsel->private;
palette_set_color (priv->custom_palette[x][y], colorsel, color);
}
**/
gboolean
gtk_color_selection_get_palette_color (GtkColorSelection *colorsel,
- gint x,
- gint y,
- gdouble *color)
+ gint x,
+ gint y,
+ gdouble *color)
{
ColorSelectionPrivate *priv;
-
+
g_return_val_if_fail (colorsel != NULL, FALSE);
g_return_val_if_fail (GTK_IS_COLOR_SELECTION (colorsel), FALSE);
- g_return_val_if_fail (x >= 0 && y >= 0 && x < CUSTOM_PALETTE_WIDTH && y < CUSTOM_PALETTE_HEIGHT, FALSE);
-
+ g_return_val_if_fail (x >= 0 && y >= 0 && x < GTK_CUSTOM_PALETTE_WIDTH && y < GTK_CUSTOM_PALETTE_HEIGHT, FALSE);
+
priv = colorsel->private;
-
+
if (GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (priv->custom_palette[x][y]), "color_set")) == 0)
return FALSE;
-
+
palette_get_color (priv->custom_palette[x][y], color);
return TRUE;
}
**/
void
gtk_color_selection_unset_palette_color (GtkColorSelection *colorsel,
- gint x,
- gint y)
+ gint x,
+ gint y)
{
ColorSelectionPrivate *priv;
-
+
g_return_if_fail (colorsel != NULL);
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
- g_return_if_fail (x >= 0 && y >= 0 && x < CUSTOM_PALETTE_WIDTH && y < CUSTOM_PALETTE_HEIGHT);
-
+ g_return_if_fail (x >= 0 && y >= 0 && x < GTK_CUSTOM_PALETTE_WIDTH && y < GTK_CUSTOM_PALETTE_HEIGHT);
+
priv = colorsel->private;
palette_unset_color (priv->custom_palette[x][y]);
}
* if the selection has stopped.
**/
gboolean
-gtk_color_selection_is_adjusting (GtkColorSelection *colorsel)
+gtk_color_selection_is_adjusting (GtkColorSelection *colorsel)
{
ColorSelectionPrivate *priv;
-
+
g_return_val_if_fail (colorsel != NULL, FALSE);
g_return_val_if_fail (GTK_IS_COLOR_SELECTION (colorsel), FALSE);
priv = colorsel->private;
-
+
return (gtk_hsv_is_adjusting (GTK_HSV (priv->triangle_colorsel)));
}
extern "C" {
#endif /* __cplusplus */
+
#define GTK_TYPE_COLOR_SELECTION (gtk_color_selection_get_type ())
#define GTK_COLOR_SELECTION(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_COLOR_SELECTION, GtkColorSelection))
#define GTK_COLOR_SELECTION_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_COLOR_SELECTION, GtkColorSelectionClass))
/* Number of elements in the custom palatte */
-#define CUSTOM_PALETTE_WIDTH 10
-#define CUSTOM_PALETTE_HEIGHT 2
+#define GTK_CUSTOM_PALETTE_WIDTH 10
+#define GTK_CUSTOM_PALETTE_HEIGHT 2
typedef struct _GtkColorSelection GtkColorSelection;
typedef struct _GtkColorSelectionClass GtkColorSelectionClass;
struct _GtkColorSelection
{
- GtkVBox parent;
+ GtkVBox parent_instance;
/* < private > */
gpointer private;
/* ColorSelection */
-GtkType gtk_color_selection_get_type (void);
-GtkWidget *gtk_color_selection_new (void);
-void gtk_color_selection_set_update_policy (GtkColorSelection *colorsel,
- GtkUpdateType policy);
-gboolean gtk_color_selection_get_use_opacity (GtkColorSelection *colorsel);
-void gtk_color_selection_set_use_opacity (GtkColorSelection *colorsel,
- gboolean use_opacity);
-gboolean gtk_color_selection_get_use_palette (GtkColorSelection *colorsel);
-void gtk_color_selection_set_use_palette (GtkColorSelection *colorsel,
- gboolean use_palette);
+GtkType gtk_color_selection_get_type (void);
+GtkWidget * gtk_color_selection_new (void);
+void gtk_color_selection_set_update_policy (GtkColorSelection *colorsel,
+ GtkUpdateType policy);
+gboolean gtk_color_selection_get_use_opacity (GtkColorSelection *colorsel);
+void gtk_color_selection_set_use_opacity (GtkColorSelection *colorsel,
+ gboolean use_opacity);
+gboolean gtk_color_selection_get_use_palette (GtkColorSelection *colorsel);
+void gtk_color_selection_set_use_palette (GtkColorSelection *colorsel,
+ gboolean use_palette);
/* The Color set is an array of doubles, of the following format:
* color[0] = red_channel;
* color[2] = blue_channel;
* color[3] = alpha_channel;
*/
-void gtk_color_selection_set_color (GtkColorSelection *colorsel,
+void gtk_color_selection_set_color (GtkColorSelection *colorsel,
gdouble *color);
-void gtk_color_selection_get_color (GtkColorSelection *colorsel,
+void gtk_color_selection_get_color (GtkColorSelection *colorsel,
gdouble *color);
-void gtk_color_selection_set_old_color (GtkColorSelection *colorsel,
+void gtk_color_selection_set_old_color (GtkColorSelection *colorsel,
gdouble *color);
-void gtk_color_selection_get_old_color (GtkColorSelection *colorsel,
+void gtk_color_selection_get_old_color (GtkColorSelection *colorsel,
gdouble *color);
-void gtk_color_selection_set_palette_color (GtkColorSelection *colorsel,
- gint x,
+void gtk_color_selection_set_palette_color (GtkColorSelection *colorsel,
+ gint x,
gint y,
gdouble *color);
-gboolean gtk_color_selection_get_palette_color (GtkColorSelection *colorsel,
+gboolean gtk_color_selection_get_palette_color (GtkColorSelection *colorsel,
gint x,
gint y,
gdouble *color);
-void gtk_color_selection_unset_palette_color(GtkColorSelection *colorsel,
+void gtk_color_selection_unset_palette_color (GtkColorSelection *colorsel,
gint x,
gint y);
-gboolean gtk_color_selection_is_adjusting (GtkColorSelection *colorsel);
+gboolean gtk_color_selection_is_adjusting (GtkColorSelection *colorsel);
#ifdef __cplusplus
gtk_color_selection_dialog_get_type (void)
{
static GtkType color_selection_dialog_type = 0;
-
+
if (!color_selection_dialog_type)
{
GtkTypeInfo colorsel_diag_info =
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
-
+
color_selection_dialog_type = gtk_type_unique (GTK_TYPE_DIALOG, &colorsel_diag_info);
}
-
+
return color_selection_dialog_type;
}
gtk_color_selection_dialog_class_init (GtkColorSelectionDialogClass *klass)
{
GtkObjectClass *object_class;
-
+
object_class = (GtkObjectClass*) klass;
-
+
color_selection_dialog_parent_class = gtk_type_class (GTK_TYPE_DIALOG);
}
gtk_color_selection_dialog_init (GtkColorSelectionDialog *colorseldiag)
{
GtkWidget *action_area_button_box, *frame;
-
+
gtk_widget_set_visual (GTK_WIDGET (colorseldiag), gdk_rgb_get_visual ());
gtk_widget_set_colormap (GTK_WIDGET (colorseldiag), gdk_rgb_get_cmap ());
-
+
gtk_widget_push_visual (gdk_rgb_get_visual ());
gtk_widget_push_colormap (gdk_rgb_get_cmap ());
-
+
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (colorseldiag)->vbox), frame);
gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
gtk_widget_show (frame);
-
+
colorseldiag->colorsel = gtk_color_selection_new ();
gtk_color_selection_set_use_palette (GTK_COLOR_SELECTION(colorseldiag->colorsel), FALSE);
gtk_color_selection_set_use_opacity (GTK_COLOR_SELECTION(colorseldiag->colorsel), FALSE);
gtk_container_add (GTK_CONTAINER (frame), colorseldiag->colorsel);
gtk_widget_show (colorseldiag->colorsel);
-
+
action_area_button_box = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX(action_area_button_box), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing (GTK_BUTTON_BOX(action_area_button_box), 5);
gtk_box_pack_end (GTK_BOX (GTK_DIALOG (colorseldiag)->action_area), action_area_button_box, TRUE, TRUE, 0);
gtk_widget_show (action_area_button_box);
-
+
colorseldiag->ok_button = gtk_button_new_with_label (_("OK"));
GTK_WIDGET_SET_FLAGS (colorseldiag->ok_button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (action_area_button_box), colorseldiag->ok_button, TRUE, TRUE, 0);
gtk_widget_grab_default (colorseldiag->ok_button);
gtk_widget_show (colorseldiag->ok_button);
-
+
colorseldiag->cancel_button = gtk_button_new_with_label (_("Cancel"));
GTK_WIDGET_SET_FLAGS (colorseldiag->cancel_button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (action_area_button_box), colorseldiag->cancel_button, TRUE, TRUE, 0);
gtk_widget_show (colorseldiag->cancel_button);
-
+
colorseldiag->help_button = gtk_button_new_with_label (_("Help"));
GTK_WIDGET_SET_FLAGS (colorseldiag->help_button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (action_area_button_box), colorseldiag->help_button, TRUE, TRUE, 0);
gtk_widget_show (colorseldiag->help_button);
-
+
gtk_widget_pop_colormap ();
gtk_widget_pop_visual ();
}
gtk_color_selection_dialog_new (const gchar *title)
{
GtkColorSelectionDialog *colorseldiag;
-
+
colorseldiag = gtk_type_new (GTK_TYPE_COLOR_SELECTION_DIALOG);
gtk_window_set_title (GTK_WINDOW (colorseldiag), title);
gtk_window_set_policy(GTK_WINDOW (colorseldiag), FALSE, FALSE, TRUE);
-
+
return GTK_WIDGET (colorseldiag);
}
-
#include <gtk/gtkdialog.h>
#include <gtk/gtkcolorsel.h>
#include <gtk/gtkvbox.h>
-#include "gtkintl.h"
+#include <gtk/gtkintl.h>
#ifdef __cplusplus
extern "C" {
struct _GtkColorSelectionDialog
{
- GtkDialog dialog;
+ GtkDialog parent_instance;
GtkWidget *colorsel;
GtkWidget *ok_button;
/* ColorSelectionDialog */
-GtkType gtk_color_selection_dialog_get_type (void);
-GtkWidget* gtk_color_selection_dialog_new (const gchar *title);
+GtkType gtk_color_selection_dialog_get_type (void);
+GtkWidget* gtk_color_selection_dialog_new (const gchar *title);
#ifdef __cplusplus
}
static void
-gtk_combo_destroy (GtkObject * combo)
+gtk_combo_destroy (GtkObject *object)
{
- gtk_widget_destroy (GTK_COMBO (combo)->popwin);
- gtk_widget_unref (GTK_COMBO (combo)->popwin);
+ GtkCombo *combo = GTK_COMBO (object);
- if (GTK_OBJECT_CLASS (parent_class)->destroy)
- (*GTK_OBJECT_CLASS (parent_class)->destroy) (combo);
+ if (combo->popwin)
+ {
+ gtk_widget_destroy (combo->popwin);
+ gtk_widget_unref (combo->popwin);
+ combo->popwin = NULL;
+ }
+
+ GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
static int
if (!show_hscroll &&
alloc_width < list_requisition.width)
{
- work_height += popup->hscrollbar->requisition.height +
- GTK_SCROLLED_WINDOW_CLASS
- (GTK_OBJECT (combo->popup)->klass)->scrollbar_spacing;
+ work_height += (popup->hscrollbar->requisition.height +
+ GTK_SCROLLED_WINDOW_GET_CLASS (combo->popup)->scrollbar_spacing);
show_hscroll = TRUE;
}
if (!show_vscroll &&
*y -= (work_height + list_requisition.height + real_height);
break;
}
- alloc_width -=
- popup->vscrollbar->requisition.width +
- GTK_SCROLLED_WINDOW_CLASS
- (GTK_OBJECT (combo->popup)->klass)->scrollbar_spacing;
+ alloc_width -= (popup->vscrollbar->requisition.width +
+ GTK_SCROLLED_WINDOW_GET_CLASS (combo->popup)->scrollbar_spacing);
show_vscroll = TRUE;
}
} while (old_width != alloc_width || old_height != work_height);
key = gtk_object_get_data (object, gtk_combo_string_key);
if (key)
- g_free (key);
+ {
+ gtk_object_remove_data (object, gtk_combo_string_key);
+ g_free (key);
+ }
}
void
container_signals[ADD] =
gtk_signal_new ("add",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkContainerClass, add),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1,
container_signals[REMOVE] =
gtk_signal_new ("remove",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkContainerClass, remove),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1,
container_signals[CHECK_RESIZE] =
gtk_signal_new ("check_resize",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkContainerClass, check_resize),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
container_signals[FOCUS] =
gtk_signal_new ("focus",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkContainerClass, focus),
gtk_marshal_ENUM__ENUM,
GTK_TYPE_DIRECTION_TYPE, 1,
container_signals[SET_FOCUS_CHILD] =
gtk_signal_new ("set-focus-child",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkContainerClass, set_focus_child),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1,
g_return_val_if_fail (container != NULL, 0);
g_return_val_if_fail (GTK_IS_CONTAINER (container), 0);
- class = GTK_CONTAINER_CLASS (GTK_OBJECT (container)->klass);
+ class = GTK_CONTAINER_GET_CLASS (container);
if (class->child_type)
slot = class->child_type (container);
else
g_return_if_fail (GTK_IS_CONTAINER (container));
g_return_if_fail (callback != NULL);
- class = GTK_CONTAINER_CLASS (GTK_OBJECT (container)->klass);
+ class = GTK_CONTAINER_GET_CLASS (container);
if (class->forall)
class->forall (container, TRUE, callback, callback_data);
g_return_if_fail (GTK_IS_CONTAINER (container));
g_return_if_fail (callback != NULL);
- class = GTK_CONTAINER_CLASS (GTK_OBJECT (container)->klass);
+ class = GTK_CONTAINER_GET_CLASS (container);
if (class->forall)
class->forall (container, FALSE, callback, callback_data);
/* first argument */
args[0].name = NULL;
- args[0].type = GTK_OBJECT(child)->klass->type;
- GTK_VALUE_OBJECT(args[0]) = GTK_OBJECT (child);
+ args[0].type = GTK_OBJECT_TYPE (child);
+ GTK_VALUE_OBJECT (args[0]) = GTK_OBJECT (child);
/* location for return value */
args[1].name = NULL;
return g_list_reverse (children);
}
-void
-gtk_container_register_toplevel (GtkContainer *container)
-{
- g_return_if_fail (container != NULL);
-
- toplevel_list = g_list_prepend (toplevel_list, container);
-
- gtk_widget_ref (GTK_WIDGET (container));
- gtk_object_sink (GTK_OBJECT (container));
-}
-
-void
-gtk_container_unregister_toplevel (GtkContainer *container)
-{
- GList *node;
-
- g_return_if_fail (container != NULL);
-
- node = g_list_find (toplevel_list, container);
- g_return_if_fail (node != NULL);
-
- toplevel_list = g_list_remove_link (toplevel_list, node);
- g_list_free_1 (node);
-
- gtk_widget_unref (GTK_WIDGET (container));
-}
-
-GList*
-gtk_container_get_toplevels (void)
-{
- /* XXX: fixme we should ref all these widgets and duplicate
- * the list.
- */
- return toplevel_list;
-}
-
static void
gtk_container_child_position_callback (GtkWidget *widget,
gpointer client_data)
{
GtkContainerClass *class;
- class = GTK_CONTAINER_CLASS (GTK_OBJECT (container)->klass);
+ class = GTK_CONTAINER_GET_CLASS (container);
if (class->composite_name)
name = class->composite_name (container, child);
}
GtkAdjustment *adjustment);
void gtk_container_set_focus_hadjustment (GtkContainer *container,
GtkAdjustment *adjustment);
-void gtk_container_register_toplevel (GtkContainer *container);
-void gtk_container_unregister_toplevel (GtkContainer *container);
-GList* gtk_container_get_toplevels (void);
void gtk_container_resize_children (GtkContainer *container);
gint x)
{
gint i, cx;
-
+
for (i = 0; i < clist->columns; i++)
if (clist->column[i].visible)
{
cx = clist->column[i].area.x + clist->hoffset;
-
+
if (x >= (cx - (COLUMN_INSET + CELL_SPACING)) &&
x <= (cx + clist->column[i].area.width + COLUMN_INSET))
return i;
}
-
+
/* no match */
return -1;
}
-#define GTK_CLIST_CLASS_FW(_widget_) GTK_CLIST_CLASS (((GtkObject*) (_widget_))->klass)
#define CLIST_UNFROZEN(clist) (((GtkCList*) (clist))->freeze_count == 0)
#define CLIST_REFRESH(clist) G_STMT_START { \
if (CLIST_UNFROZEN (clist)) \
- GTK_CLIST_CLASS_FW (clist)->refresh ((GtkCList*) (clist)); \
+ GTK_CLIST_GET_CLASS (clist)->refresh ((GtkCList*) (clist)); \
} G_STMT_END
gtk_ctree_get_type (void)
{
static GtkType ctree_type = 0;
-
+
if (!ctree_type)
{
static const GtkTypeInfo ctree_info =
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
-
+
ctree_type = gtk_type_unique (GTK_TYPE_CLIST, &ctree_info);
}
-
+
return ctree_type;
}
GtkWidgetClass *widget_class;
GtkCListClass *clist_class;
GtkBindingSet *binding_set;
-
+
object_class = (GtkObjectClass *) klass;
widget_class = (GtkWidgetClass *) klass;
container_class = (GtkContainerClass *) klass;
clist_class = (GtkCListClass *) klass;
-
+
parent_class = gtk_type_class (GTK_TYPE_CLIST);
container_class = gtk_type_class (GTK_TYPE_CONTAINER);
-
+
gtk_object_add_arg_type ("GtkCTree::n_columns",
GTK_TYPE_UINT,
GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT_ONLY,
ARG_EXPANDER_STYLE);
object_class->set_arg = gtk_ctree_set_arg;
object_class->get_arg = gtk_ctree_get_arg;
-
+
ctree_signals[TREE_SELECT_ROW] =
gtk_signal_new ("tree_select_row",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_select_row),
gtk_marshal_NONE__POINTER_INT,
GTK_TYPE_NONE, 2, GTK_TYPE_CTREE_NODE, GTK_TYPE_INT);
ctree_signals[TREE_UNSELECT_ROW] =
gtk_signal_new ("tree_unselect_row",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_unselect_row),
gtk_marshal_NONE__POINTER_INT,
GTK_TYPE_NONE, 2, GTK_TYPE_CTREE_NODE, GTK_TYPE_INT);
ctree_signals[TREE_EXPAND] =
gtk_signal_new ("tree_expand",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_expand),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1, GTK_TYPE_CTREE_NODE);
ctree_signals[TREE_COLLAPSE] =
gtk_signal_new ("tree_collapse",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_collapse),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1, GTK_TYPE_CTREE_NODE);
ctree_signals[TREE_MOVE] =
gtk_signal_new ("tree_move",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_move),
gtk_marshal_NONE__POINTER_POINTER_POINTER,
GTK_TYPE_NONE, 3, GTK_TYPE_CTREE_NODE,
ctree_signals[CHANGE_FOCUS_ROW_EXPANSION] =
gtk_signal_new ("change_focus_row_expansion",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCTreeClass,
change_focus_row_expansion),
gtk_marshal_NONE__ENUM,
GTK_TYPE_NONE, 1, GTK_TYPE_CTREE_EXPANSION_TYPE);
gtk_object_class_add_signals (object_class, ctree_signals, LAST_SIGNAL);
-
+
widget_class->realize = gtk_ctree_realize;
widget_class->unrealize = gtk_ctree_unrealize;
widget_class->button_press_event = gtk_ctree_button_press;
-
+
widget_class->drag_begin = gtk_ctree_drag_begin;
widget_class->drag_motion = gtk_ctree_drag_motion;
widget_class->drag_data_received = gtk_ctree_drag_data_received;
-
+
clist_class->select_row = real_select_row;
clist_class->unselect_row = real_unselect_row;
clist_class->row_move = real_row_move;
clist_class->sort_list = real_sort_list;
clist_class->set_cell_contents = set_cell_contents;
clist_class->cell_size_request = cell_size_request;
-
+
klass->tree_select_row = real_tree_select;
klass->tree_unselect_row = real_tree_unselect;
klass->tree_expand = real_tree_expand;
klass->tree_collapse = real_tree_collapse;
klass->tree_move = real_tree_move;
klass->change_focus_row_expansion = change_focus_row_expansion;
-
+
binding_set = gtk_binding_set_by_class (klass);
gtk_binding_entry_add_signal (binding_set,
'+', GDK_SHIFT_MASK,
guint arg_id)
{
GtkCTree *ctree;
-
+
ctree = GTK_CTREE (object);
-
+
switch (arg_id)
{
case ARG_N_COLUMNS: /* construct-only arg, only set when !GTK_CONSTRUCTED */
guint arg_id)
{
GtkCTree *ctree;
-
+
ctree = GTK_CTREE (object);
-
+
switch (arg_id)
{
case ARG_N_COLUMNS:
gtk_ctree_init (GtkCTree *ctree)
{
GtkCList *clist;
-
+
GTK_CLIST_SET_FLAG (ctree, CLIST_DRAW_DRAG_RECT);
GTK_CLIST_SET_FLAG (ctree, CLIST_DRAW_DRAG_LINE);
-
+
clist = GTK_CLIST (ctree);
-
+
ctree->tree_indent = 20;
ctree->tree_spacing = 5;
ctree->tree_column = 0;
ctree->expander_style = GTK_CTREE_EXPANDER_SQUARE;
ctree->drag_compare = NULL;
ctree->show_stub = TRUE;
-
+
clist->button_actions[0] |= GTK_BUTTON_EXPANDS;
}
{
GtkCList *clist;
gint i;
-
+
clist = GTK_CLIST (ctree);
-
+
if (GTK_CTREE_ROW (node)->row.style)
GTK_CTREE_ROW (node)->row.style =
gtk_style_attach (GTK_CTREE_ROW (node)->row.style, clist->clist_window);
-
+
if (GTK_CTREE_ROW (node)->row.fg_set || GTK_CTREE_ROW (node)->row.bg_set)
{
GdkColormap *colormap;
-
+
colormap = gtk_widget_get_colormap (GTK_WIDGET (ctree));
if (GTK_CTREE_ROW (node)->row.fg_set)
gdk_color_alloc (colormap, &(GTK_CTREE_ROW (node)->row.foreground));
if (GTK_CTREE_ROW (node)->row.bg_set)
gdk_color_alloc (colormap, &(GTK_CTREE_ROW (node)->row.background));
}
-
+
for (i = 0; i < clist->columns; i++)
if (GTK_CTREE_ROW (node)->row.cell[i].style)
GTK_CTREE_ROW (node)->row.cell[i].style =
{
GtkCList *clist;
gint i;
-
+
clist = GTK_CLIST (ctree);
-
+
if (GTK_CTREE_ROW (node)->row.style)
gtk_style_detach (GTK_CTREE_ROW (node)->row.style);
for (i = 0; i < clist->columns; i++)
GtkCTreeNode *node;
GtkCTreeNode *child;
gint i;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CTREE (widget));
-
+
GTK_WIDGET_CLASS (parent_class)->realize (widget);
-
+
ctree = GTK_CTREE (widget);
clist = GTK_CLIST (widget);
-
+
node = GTK_CTREE_NODE (clist->row_list);
for (i = 0; i < clist->rows; i++)
{
gtk_ctree_pre_recursive (ctree, child, ctree_attach_styles, NULL);
node = GTK_CTREE_NODE_NEXT (node);
}
-
+
values.foreground = widget->style->fg[GTK_STATE_NORMAL];
values.background = widget->style->base[GTK_STATE_NORMAL];
values.subwindow_mode = GDK_INCLUDE_INFERIORS;
GDK_GC_BACKGROUND |
GDK_GC_SUBWINDOW |
GDK_GC_LINE_STYLE);
-
+
if (ctree->line_style == GTK_CTREE_LINES_DOTTED)
{
gdk_gc_set_line_attributes (ctree->lines_gc, 1,
{
GtkCTree *ctree;
GtkCList *clist;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CTREE (widget));
-
+
GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
-
+
ctree = GTK_CTREE (widget);
clist = GTK_CLIST (widget);
-
+
if (GTK_WIDGET_REALIZED (widget))
{
GtkCTreeNode *node;
GtkCTreeNode *child;
gint i;
-
+
node = GTK_CTREE_NODE (clist->row_list);
for (i = 0; i < clist->rows; i++)
{
node = GTK_CTREE_NODE_NEXT (node);
}
}
-
+
gdk_gc_destroy (ctree->lines_gc);
}
GtkCTree *ctree;
GtkCList *clist;
gint button_actions;
-
+
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CTREE (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
-
+
ctree = GTK_CTREE (widget);
clist = GTK_CLIST (widget);
-
+
button_actions = clist->button_actions[event->button - 1];
-
+
if (button_actions == GTK_BUTTON_IGNORED)
return FALSE;
-
+
if (event->window == clist->clist_window)
{
GtkCTreeNode *work;
gint y;
gint row;
gint column;
-
+
x = event->x;
y = event->y;
-
+
if (!gtk_clist_get_selection_info (clist, x, y, &row, &column))
return FALSE;
-
+
work = GTK_CTREE_NODE (g_list_nth (clist->row_list, row));
-
+
if (button_actions & GTK_BUTTON_EXPANDS &&
(GTK_CTREE_ROW (work)->children && !GTK_CTREE_ROW (work)->is_leaf &&
(event->type == GDK_2BUTTON_PRESS ||
gtk_ctree_collapse (ctree, work);
else
gtk_ctree_expand (ctree, work);
-
+
return FALSE;
}
}
gint level;
gint i;
gint y = 0;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
-
+
ctree = GTK_CTREE (clist);
-
+
level = ((GtkCTreeRow *)(dest_row))->level;
-
+
y = ROW_TOP_YPIXEL (clist, dest_row_number) - 1;
-
+
switch (drag_pos)
{
case GTK_CLIST_DRAG_NONE:
COLUMN_LEFT_XPIXEL(clist, ctree->tree_column - 1)+
clist->column[ctree->tree_column - 1].area.width,
y);
-
+
gdk_draw_line (clist->clist_window, clist->xor_gc,
COLUMN_LEFT_XPIXEL(clist, ctree->tree_column) +
ctree->tree_indent * level -
y,
COLUMN_LEFT_XPIXEL(clist, clist->columns - 1) +
clist->column[clist->columns - 1].area.width, y);
-
+
gdk_draw_line (clist->clist_window, clist->xor_gc,
0, y, COLUMN_LEFT_XPIXEL(clist, ctree->tree_column)
+ clist->column[ctree->tree_column].area.width -
break;
case GTK_CLIST_DRAG_INTO:
y = ROW_TOP_YPIXEL (clist, dest_row_number) + clist->row_height;
-
+
if (clist->column[ctree->tree_column].visible)
switch (clist->column[ctree->tree_column].justification)
{
points[1].y = points[0].y;
points[2].x = points[1].x;
points[2].y = points[3].y;
-
+
for (i = 0; i < 3; i++)
gdk_draw_line (clist->clist_window, clist->xor_gc,
points[i].x, points[i].y,
points[i+1].x, points[i+1].y);
-
+
if (ctree->tree_column > 0)
{
points[0].x = COLUMN_LEFT_XPIXEL(clist,
points[1].y = points[0].y;
points[2].x = 0;
points[2].y = points[3].y;
-
+
for (i = 0; i < 3; i++)
gdk_draw_line (clist->clist_window, clist->xor_gc,
points[i].x, points[i].y, points[i+1].x,
points[1].y = points[0].y;
points[2].x = 0;
points[2].y = points[3].y;
-
+
for (i = 0; i < 3; i++)
gdk_draw_line (clist->clist_window, clist->xor_gc,
points[i].x, points[i].y,
points[i+1].x, points[i+1].y);
-
+
if (ctree->tree_column < clist->columns - 1)
{
points[0].x = COLUMN_LEFT_XPIXEL(clist, ctree->tree_column +1);
points[1].y = points[0].y;
points[2].x = points[1].x;
points[2].y = points[3].y;
-
+
for (i = 0; i < 3; i++)
gdk_draw_line (clist->clist_window, clist->xor_gc,
points[i].x, points[i].y,
{
gint xsrc = 0;
gint ysrc = 0;
-
+
if (mask)
{
gdk_gc_set_clip_mask (fg_gc, mask);
}
if (x + width > clip_rectangle->x + clip_rectangle->width)
width = clip_rectangle->x + clip_rectangle->width - x;
-
+
if (y < clip_rectangle->y)
{
ysrc = clip_rectangle->y - y;
}
if (y + height > clip_rectangle->y + clip_rectangle->height)
height = clip_rectangle->y + clip_rectangle->height - y;
-
+
if (width > 0 && height > 0)
gdk_draw_pixmap (window, fg_gc, pixmap, xsrc, ysrc, x, y, width, height);
-
+
if (mask)
{
gdk_gc_set_clip_rectangle (fg_gc, NULL);
gdk_gc_set_clip_origin (fg_gc, 0, 0);
}
-
+
return x + MAX (width, 0);
}
GdkGC **bg_gc)
{
gint fg_state;
-
+
if ((state == GTK_STATE_NORMAL) &&
(GTK_WIDGET (clist)->state == GTK_STATE_INSENSITIVE))
fg_state = GTK_STATE_INSENSITIVE;
else
fg_state = state;
-
+
if (clist_row->cell[column].style)
{
if (style)
else
*bg_gc = GTK_WIDGET (clist)->style->base_gc[state];
}
-
+
if (state != GTK_STATE_SELECTED)
{
if (fg_gc && clist_row->fg_set)
GdkPoint points[3];
gint justification_factor;
gint y;
-
- if (ctree->expander_style == GTK_CTREE_EXPANDER_NONE)
- return x;
-
+
+ if (ctree->expander_style == GTK_CTREE_EXPANDER_NONE)
+ return x;
+
clist = GTK_CLIST (ctree);
if (clist->column[ctree->tree_column].justification == GTK_JUSTIFY_RIGHT)
justification_factor = -1;
justification_factor = 1;
y = (clip_rectangle->y + (clip_rectangle->height - PM_SIZE) / 2 -
(clip_rectangle->height + 1) % 2);
-
+
if (!ctree_row->children)
{
switch (ctree->expander_style)
return x + justification_factor * (PM_SIZE + 1);
}
}
-
+
gdk_gc_set_clip_rectangle (style->fg_gc[GTK_STATE_NORMAL], clip_rectangle);
gdk_gc_set_clip_rectangle (style->base_gc[GTK_STATE_NORMAL], clip_rectangle);
-
+
switch (ctree->expander_style)
{
case GTK_CTREE_EXPANDER_NONE:
justification_factor * (2 * (PM_SIZE + 2) / 3 - 1));
points[2].y = points[0].y + (PM_SIZE + 2) / 2;
}
-
+
gdk_draw_polygon (clist->clist_window, style->base_gc[GTK_STATE_NORMAL],
TRUE, points, 3);
gdk_draw_polygon (clist->clist_window, style->fg_gc[GTK_STATE_NORMAL],
FALSE, points, 3);
-
+
x += justification_factor * (PM_SIZE + 3);
break;
case GTK_CTREE_EXPANDER_SQUARE:
case GTK_CTREE_EXPANDER_CIRCULAR:
if (justification_factor == -1)
x += justification_factor * (PM_SIZE + 1);
-
+
if (ctree->expander_style == GTK_CTREE_EXPANDER_CIRCULAR)
{
gdk_draw_arc (clist->clist_window, style->base_gc[GTK_STATE_NORMAL],
style->fg_gc[GTK_STATE_NORMAL], FALSE,
x, y, PM_SIZE, PM_SIZE);
}
-
+
gdk_draw_line (clist->clist_window, style->fg_gc[GTK_STATE_NORMAL],
x + 2, y + PM_SIZE / 2, x + PM_SIZE - 2, y + PM_SIZE / 2);
-
+
if (!ctree_row->expanded)
gdk_draw_line (clist->clist_window, style->fg_gc[GTK_STATE_NORMAL],
x + PM_SIZE / 2, y + 2,
x + PM_SIZE / 2, y + PM_SIZE - 2);
-
+
if (justification_factor == 1)
x += justification_factor * (PM_SIZE + 1);
break;
}
-
+
gdk_gc_set_clip_rectangle (style->fg_gc[GTK_STATE_NORMAL], NULL);
gdk_gc_set_clip_rectangle (style->base_gc[GTK_STATE_NORMAL], NULL);
-
+
return x;
}
clist = GTK_CLIST (ctree);
ycenter = clip_rectangle->y + (clip_rectangle->height / 2);
justify_right = (clist->column[column].justification == GTK_JUSTIFY_RIGHT);
-
+
if (justify_right)
{
offset = (clip_rectangle->x + clip_rectangle->width - 1 -
offset = clip_rectangle->x + ctree->tree_indent * (ctree_row->level - 1);
justification_factor = 1;
}
-
+
switch (ctree->line_style)
{
case GTK_CTREE_LINES_NONE:
break;
case GTK_CTREE_LINES_TABBED:
xcenter = offset + justification_factor * TAB_SIZE;
-
+
column_right = (COLUMN_LEFT_XPIXEL (clist, ctree->tree_column) +
clist->column[ctree->tree_column].area.width +
COLUMN_INSET);
column_left = (COLUMN_LEFT_XPIXEL (clist, ctree->tree_column) -
COLUMN_INSET - CELL_SPACING);
-
+
if (area)
{
tree_rectangle.y = crect->y;
tree_rectangle.height = crect->height;
-
+
if (justify_right)
{
tree_rectangle.x = xcenter;
tree_rectangle.x = column_left;
tree_rectangle.width = xcenter - column_left;
}
-
+
if (!gdk_rectangle_intersect (area, &tree_rectangle, &tc_rectangle))
{
offset += justification_factor * 3;
break;
}
}
-
+
gdk_gc_set_clip_rectangle (ctree->lines_gc, crect);
-
+
next_level = ctree_row->level;
-
+
if (!ctree_row->sibling || (ctree_row->children && ctree_row->expanded))
{
node = gtk_ctree_find_node_ptr (ctree, ctree_row);
else
next_level = 0;
}
-
+
if (ctree->tree_indent > 0)
{
node = ctree_row->parent;
while (node)
{
xcenter -= (justification_factor * ctree->tree_indent);
-
+
if ((justify_right && xcenter < column_left) ||
(!justify_right && xcenter > column_right))
{
node = GTK_CTREE_ROW (node)->parent;
continue;
}
-
+
tree_rectangle.y = cell_rectangle->y;
tree_rectangle.height = cell_rectangle->height;
if (justify_right)
tree_rectangle.width = MIN (column_right - xcenter,
ctree->tree_indent);
}
-
+
if (!area || gdk_rectangle_intersect (area, &tree_rectangle,
&tc_rectangle))
{
get_cell_style (clist, >K_CTREE_ROW (node)->row,
state, column, NULL, NULL, &bg_gc);
-
+
if (bg_gc == clist->bg_gc)
gdk_gc_set_foreground
(clist->bg_gc, >K_CTREE_ROW (node)->row.background);
-
+
if (!area)
gdk_draw_rectangle (clist->clist_window, bg_gc, TRUE,
tree_rectangle.x,
else
{
gint width;
-
+
offset_x = MIN (ctree->tree_indent, 2 * TAB_SIZE);
width = offset_x / 2 + offset_x % 2;
-
+
parent = GTK_CTREE_ROW (node)->parent;
-
+
tree_rectangle.y = ycenter;
tree_rectangle.height = (cell_rectangle->y - ycenter +
cell_rectangle->height);
-
+
if (justify_right)
{
tree_rectangle.x = MAX(xcenter + 1 - width, column_left);
tree_rectangle.width = MIN (column_right - xcenter,
width);
}
-
+
if (!area ||
gdk_rectangle_intersect (area, &tree_rectangle,
&tc_rectangle))
bg_gc = style->base_gc[state];
else
bg_gc = GTK_WIDGET (clist)->style->base_gc[state];
-
+
if (!area)
gdk_draw_rectangle (clist->clist_window, bg_gc, TRUE,
tree_rectangle.x,
tc_rectangle.width,
tc_rectangle.height);
}
-
+
get_cell_style (clist, >K_CTREE_ROW (node)->row,
state, column, NULL, NULL, &bg_gc);
if (bg_gc == clist->bg_gc)
gdk_gc_set_foreground
(clist->bg_gc, >K_CTREE_ROW (node)->row.background);
-
+
gdk_gc_set_clip_rectangle (bg_gc, crect);
gdk_draw_arc (clist->clist_window, bg_gc, TRUE,
xcenter - (justify_right * offset_x),
offset_x, clist->row_height,
(180 + (justify_right * 90)) * 64, 90 * 64);
gdk_gc_set_clip_rectangle (bg_gc, NULL);
-
+
gdk_draw_line (clist->clist_window, ctree->lines_gc,
xcenter, cell_rectangle->y, xcenter, ycenter);
-
+
if (justify_right)
gdk_draw_arc (clist->clist_window, ctree->lines_gc, FALSE,
xcenter - offset_x, cell_rectangle->y,
node = GTK_CTREE_ROW (node)->parent;
}
}
-
+
if (state != GTK_STATE_SELECTED)
{
tree_rectangle.y = clip_rectangle->y;
tree_rectangle.width = COLUMN_INSET + CELL_SPACING +
MIN (clist->column[ctree->tree_column].area.width + COLUMN_INSET,
TAB_SIZE);
-
+
if (justify_right)
tree_rectangle.x = MAX (xcenter + 1, column_left);
else
tree_rectangle.x = column_left;
-
+
if (!area)
gdk_draw_rectangle (clist->clist_window,
GTK_WIDGET
tc_rectangle.width,
tc_rectangle.height);
}
-
+
xcenter = offset + (justification_factor * ctree->tree_indent / 2);
-
+
get_cell_style (clist, &ctree_row->row, state, column, NULL, NULL,
&bg_gc);
if (bg_gc == clist->bg_gc)
gdk_gc_set_foreground (clist->bg_gc, &ctree_row->row.background);
-
+
gdk_gc_set_clip_rectangle (bg_gc, crect);
if (ctree_row->is_leaf)
{
GdkPoint points[6];
-
+
points[0].x = offset + justification_factor * TAB_SIZE;
points[0].y = cell_rectangle->y;
-
+
points[1].x = points[0].x - justification_factor * 4;
points[1].y = points[0].y;
-
+
points[2].x = points[1].x - justification_factor * 2;
points[2].y = points[1].y + 3;
-
+
points[3].x = points[2].x;
points[3].y = points[2].y + clist->row_height - 5;
-
+
points[4].x = points[3].x + justification_factor * 2;
points[4].y = points[3].y + 3;
-
+
points[5].x = points[4].x + justification_factor * 4;
points[5].y = points[4].y;
-
+
gdk_draw_polygon (clist->clist_window, bg_gc, TRUE, points, 6);
gdk_draw_lines (clist->clist_window, ctree->lines_gc, points, 6);
}
}
gdk_gc_set_clip_rectangle (bg_gc, NULL);
gdk_gc_set_clip_rectangle (ctree->lines_gc, NULL);
-
+
offset += justification_factor * 3;
break;
default:
xcenter = offset + justification_factor * PM_SIZE / 2;
-
+
if (area)
{
tree_rectangle.y = crect->y;
tree_rectangle.height = crect->height;
-
+
if (justify_right)
{
tree_rectangle.x = xcenter - PM_SIZE / 2 - 2;
tree_rectangle.width = (xcenter + PM_SIZE / 2 + 2 -
clip_rectangle->x);
}
-
+
if (!gdk_rectangle_intersect (area, &tree_rectangle, &tc_rectangle))
break;
}
-
+
offset_x = 1;
offset_y = 0;
if (ctree->line_style == GTK_CTREE_LINES_DOTTED)
offset_x += abs((clip_rectangle->x + clist->hoffset) % 2);
offset_y = abs((cell_rectangle->y + clist->voffset) % 2);
}
-
+
clip_rectangle->y--;
clip_rectangle->height++;
gdk_gc_set_clip_rectangle (ctree->lines_gc, clip_rectangle);
cell_rectangle->y + offset_y : ycenter,
xcenter,
(ctree_row->sibling) ? crect->y +crect->height : ycenter);
-
+
gdk_draw_line (clist->clist_window, ctree->lines_gc,
xcenter + (justification_factor * offset_x), ycenter,
xcenter + (justification_factor * (PM_SIZE / 2 + 2)),
ycenter);
-
+
node = ctree_row->parent;
while (node)
{
xcenter -= (justification_factor * ctree->tree_indent);
-
+
if (GTK_CTREE_ROW (node)->sibling)
gdk_draw_line (clist->clist_window, ctree->lines_gc,
xcenter, cell_rectangle->y + offset_y,
gint offset = 0;
gint state;
gint i;
-
+
g_return_if_fail (clist != NULL);
-
+
/* bail now if we arn't drawable yet */
if (!GTK_WIDGET_DRAWABLE (clist) || row < 0 || row >= clist->rows)
return;
-
+
widget = GTK_WIDGET (clist);
ctree = GTK_CTREE (clist);
-
+
/* if the function is passed the pointer to the row instead of null,
* it avoids this expensive lookup */
if (!clist_row)
clist_row = (g_list_nth (clist->row_list, row))->data;
-
+
/* rectangle of the entire row */
row_rectangle.x = 0;
row_rectangle.y = ROW_TOP_YPIXEL (clist, row);
row_rectangle.width = clist->clist_window_width;
row_rectangle.height = clist->row_height;
-
+
/* rectangle of the cell spacing above the row */
cell_rectangle.x = 0;
cell_rectangle.y = row_rectangle.y - CELL_SPACING;
cell_rectangle.width = row_rectangle.width;
cell_rectangle.height = CELL_SPACING;
-
+
/* rectangle used to clip drawing operations, its y and height
* positions only need to be set once, so we set them once here.
* the x and width are set withing the drawing loop below once per
* column */
clip_rectangle.y = row_rectangle.y;
clip_rectangle.height = row_rectangle.height;
-
+
if (clist_row->state == GTK_STATE_NORMAL)
{
if (clist_row->fg_set)
}
state = clist_row->state;
-
+
gdk_gc_set_foreground (ctree->lines_gc,
&widget->style->fg[clist_row->state]);
-
+
/* draw the cell borders */
if (area)
{
rect = &intersect_rectangle;
crect = &intersect_rectangle;
-
+
if (gdk_rectangle_intersect (area, &cell_rectangle, crect))
gdk_draw_rectangle (clist->clist_window,
widget->style->base_gc[GTK_STATE_ACTIVE], TRUE,
{
rect = &clip_rectangle;
crect = &cell_rectangle;
-
+
gdk_draw_rectangle (clist->clist_window,
widget->style->base_gc[GTK_STATE_ACTIVE], TRUE,
crect->x, crect->y, crect->width, crect->height);
}
-
+
/* horizontal black lines */
if (ctree->line_style == GTK_CTREE_LINES_TABBED)
{
-
+
column_right = (COLUMN_LEFT_XPIXEL (clist, ctree->tree_column) +
clist->column[ctree->tree_column].area.width +
COLUMN_INSET);
column_left = (COLUMN_LEFT_XPIXEL (clist, ctree->tree_column) -
COLUMN_INSET - (ctree->tree_column != 0) * CELL_SPACING);
-
+
switch (clist->column[ctree->tree_column].justification)
{
case GTK_JUSTIFY_CENTER:
case GTK_JUSTIFY_LEFT:
offset = (column_left + ctree->tree_indent *
(((GtkCTreeRow *)clist_row)->level - 1));
-
+
gdk_draw_line (clist->clist_window, ctree->lines_gc,
MIN (offset + TAB_SIZE, column_right),
cell_rectangle.y,
case GTK_JUSTIFY_RIGHT:
offset = (column_right - 1 - ctree->tree_indent *
(((GtkCTreeRow *)clist_row)->level - 1));
-
+
gdk_draw_line (clist->clist_window, ctree->lines_gc,
-1, cell_rectangle.y,
MAX (offset - TAB_SIZE, column_left),
break;
}
}
-
+
/* the last row has to clear its bottom cell spacing too */
if (clist_row == clist->row_list_end->data)
{
cell_rectangle.y += clist->row_height + CELL_SPACING;
-
+
if (!area || gdk_rectangle_intersect (area, &cell_rectangle, crect))
{
gdk_draw_rectangle (clist->clist_window,
widget->style->base_gc[GTK_STATE_ACTIVE], TRUE,
crect->x, crect->y, crect->width, crect->height);
-
+
/* horizontal black lines */
if (ctree->line_style == GTK_CTREE_LINES_TABBED)
{
}
}
}
-
+
for (last_column = clist->columns - 1;
last_column >= 0 && !clist->column[last_column].visible; last_column--)
;
-
+
/* iterate and draw all the columns (row cells) and draw their contents */
for (i = 0; i < clist->columns; i++)
{
GtkStyle *style;
GdkGC *fg_gc;
GdkGC *bg_gc;
-
+
gint width;
gint height;
gint pixmap_width;
gint string_width;
gint old_offset;
gint row_center_offset;
-
+
if (!clist->column[i].visible)
continue;
-
+
get_cell_style (clist, clist_row, state, i, &style, &fg_gc, &bg_gc);
-
+
/* calculate clipping region */
clip_rectangle.x = clist->column[i].area.x + clist->hoffset;
clip_rectangle.width = clist->column[i].area.width;
-
+
cell_rectangle.x = clip_rectangle.x - COLUMN_INSET - CELL_SPACING;
cell_rectangle.width = (clip_rectangle.width + 2 * COLUMN_INSET +
(1 + (i == last_column)) * CELL_SPACING);
cell_rectangle.y = clip_rectangle.y;
cell_rectangle.height = clip_rectangle.height;
-
+
string_width = 0;
pixmap_width = 0;
-
+
if (area && !gdk_rectangle_intersect (area, &cell_rectangle,
&intersect_rectangle))
{
{
gdk_draw_rectangle (clist->clist_window, bg_gc, TRUE,
crect->x, crect->y, crect->width, crect->height);
-
+
/* calculate real width for column justification */
switch (clist_row->cell[i].type)
{
gdk_window_get_size
(GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap,
&pixmap_width, &height);
-
+
width = pixmap_width;
-
+
if (GTK_CELL_PIXTEXT (clist_row->cell[i])->text)
{
string_width = gdk_string_width
(style->font, GTK_CELL_PIXTEXT (clist_row->cell[i])->text);
width += string_width;
}
-
+
if (GTK_CELL_PIXTEXT (clist_row->cell[i])->text &&
GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap)
width += GTK_CELL_PIXTEXT (clist_row->cell[i])->spacing;
-
+
if (i == ctree->tree_column)
width += (ctree->tree_indent *
((GtkCTreeRow *)clist_row)->level);
continue;
break;
}
-
+
switch (clist->column[i].justification)
{
case GTK_JUSTIFY_LEFT:
(clip_rectangle.width / 2) - (width / 2));
break;
};
-
+
if (i != ctree->tree_column)
{
offset += clist_row->cell[i].horizontal;
1.5 + style->font->ascent);
else
row_center_offset = clist->row_center_offset;
-
+
gdk_gc_set_clip_rectangle (fg_gc, &clip_rectangle);
gdk_draw_string
(clist->clist_window, style->font, fg_gc,
continue;
}
}
-
+
if (bg_gc == clist->bg_gc)
gdk_gc_set_background (ctree->lines_gc, &clist_row->background);
-
+
/* draw ctree->tree_column */
cell_rectangle.y -= CELL_SPACING;
cell_rectangle.height += CELL_SPACING;
-
+
if (area && !gdk_rectangle_intersect (area, &cell_rectangle,
&intersect_rectangle))
continue;
-
+
/* draw lines */
offset = gtk_ctree_draw_lines (ctree, (GtkCTreeRow *)clist_row, row, i,
state, &clip_rectangle, &cell_rectangle,
crect, area, style);
-
+
/* draw expander */
offset = gtk_ctree_draw_expander (ctree, (GtkCTreeRow *)clist_row,
style, &clip_rectangle, offset);
-
+
if (clist->column[i].justification == GTK_JUSTIFY_RIGHT)
offset -= ctree->tree_spacing;
else
offset += ctree->tree_spacing;
-
+
if (clist->column[i].justification == GTK_JUSTIFY_RIGHT)
offset -= (pixmap_width + clist_row->cell[i].horizontal);
else
offset += clist_row->cell[i].horizontal;
-
+
old_offset = offset;
offset = draw_cell_pixmap (clist->clist_window, &clip_rectangle, fg_gc,
GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap,
clip_rectangle.y + clist_row->cell[i].vertical
+ (clip_rectangle.height - height) / 2,
pixmap_width, height);
-
+
if (string_width)
{
if (clist->column[i].justification == GTK_JUSTIFY_RIGHT)
if (GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap)
offset += GTK_CELL_PIXTEXT (clist_row->cell[i])->spacing;
}
-
+
if (style != GTK_WIDGET (clist)->style)
row_center_offset = (((clist->row_height - style->font->ascent -
style->font->descent - 1) / 2) +
}
gdk_gc_set_clip_rectangle (fg_gc, NULL);
}
-
+
/* draw focus rectangle */
if (clist->focus_row == row &&
GTK_WIDGET_CAN_FOCUS (widget) && GTK_WIDGET_HAS_FOCUS (widget))
GtkCList *clist;
clist = GTK_CLIST (ctree);
-
+
if (CLIST_UNFROZEN (clist) && gtk_ctree_is_viewable (ctree, node))
{
GtkCTreeNode *work;
num++;
}
if (work && gtk_clist_row_is_visible (clist, num) != GTK_VISIBILITY_NONE)
- GTK_CLIST_CLASS_FW (clist)->draw_row
+ GTK_CLIST_GET_CLASS (clist)->draw_row
(clist, NULL, num, GTK_CLIST_ROW ((GList *) node));
}
}
if (!node)
return NULL;
-
+
work = GTK_CTREE_ROW (node)->children;
-
+
if (!work || !GTK_CTREE_ROW (node)->expanded)
return node;
-
+
while (GTK_CTREE_ROW (work)->sibling)
work = GTK_CTREE_ROW (work)->sibling;
-
+
return gtk_ctree_last_visible (ctree, work);
}
g_return_if_fail (node != NULL);
g_return_if_fail (node != sibling);
g_return_if_fail (node != parent);
-
+
clist = GTK_CLIST (ctree);
-
+
if (update_focus_row && clist->selection_mode == GTK_SELECTION_EXTENDED)
{
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
clist->undo_selection = NULL;
clist->undo_unselection = NULL;
}
-
+
for (rows = 1, list_end = (GList *)node; list_end->next;
list_end = list_end->next)
rows++;
-
+
GTK_CTREE_ROW (node)->parent = parent;
GTK_CTREE_ROW (node)->sibling = sibling;
-
+
if (!parent || (parent && (gtk_ctree_is_viewable (ctree, parent) &&
GTK_CTREE_ROW (parent)->expanded)))
{
visible = TRUE;
clist->rows += rows;
}
-
+
if (parent)
work = (GList *)(GTK_CTREE_ROW (parent)->children);
else
work = clist->row_list;
-
+
if (sibling)
{
if (work != (GList *)sibling)
work = (GList *)(GTK_CTREE_ROW (work)->sibling);
GTK_CTREE_ROW (work)->sibling = node;
}
-
+
if (sibling == GTK_CTREE_NODE (clist->row_list))
clist->row_list = (GList *) node;
if (GTK_CTREE_NODE_PREV (sibling) &&
}
}
}
-
+
gtk_ctree_pre_recursive (ctree, node, tree_update_level, NULL);
-
+
if (clist->row_list_end == NULL ||
clist->row_list_end->next == (GList *)node)
clist->row_list_end = list_end;
-
+
if (visible && update_focus_row)
{
gint pos;
-
+
pos = g_list_position (clist->row_list, (GList *)node);
-
+
if (pos <= clist->focus_row)
{
clist->focus_row += rows;
GtkCTreeNode *work;
GtkCTreeNode *parent;
GList *list;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
-
+
clist = GTK_CLIST (ctree);
if (update_focus_row && clist->selection_mode == GTK_SELECTION_EXTENDED)
{
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
clist->undo_selection = NULL;
clist->undo_unselection = NULL;
}
-
+
visible = gtk_ctree_is_viewable (ctree, node);
-
+
/* clist->row_list_end unlinked ? */
if (visible &&
(GTK_CTREE_NODE_NEXT (node) == NULL ||
gtk_ctree_is_ancestor (ctree, node,
GTK_CTREE_NODE (clist->row_list_end)))))
clist->row_list_end = (GList *) (GTK_CTREE_NODE_PREV (node));
-
+
/* update list */
rows = 0;
level = GTK_CTREE_ROW (node)->level;
work = GTK_CTREE_NODE_NEXT (work);
rows++;
}
-
+
if (visible)
{
clist->rows -= (rows + 1);
-
+
if (update_focus_row)
{
gint pos;
clist->undo_anchor = clist->focus_row;
}
}
-
+
if (work)
{
list = (GList *)GTK_CTREE_NODE_PREV (work);
list = (GList *)work;
list->prev = (GList *)GTK_CTREE_NODE_PREV (node);
}
-
+
if (GTK_CTREE_NODE_PREV (node) &&
GTK_CTREE_NODE_NEXT (GTK_CTREE_NODE_PREV (node)) == node)
{
list = (GList *)GTK_CTREE_NODE_PREV (node);
list->next = (GList *)work;
}
-
+
/* update tree */
parent = GTK_CTREE_ROW (node)->parent;
if (parent)
else
{
GtkCTreeNode *sibling;
-
+
sibling = GTK_CTREE_ROW (parent)->children;
while (GTK_CTREE_ROW (sibling)->sibling != node)
sibling = GTK_CTREE_ROW (sibling)->sibling;
else
{
GtkCTreeNode *sibling;
-
+
sibling = GTK_CTREE_NODE (clist->row_list);
while (GTK_CTREE_ROW (sibling)->sibling != node)
sibling = GTK_CTREE_ROW (sibling)->sibling;
{
GtkCTree *ctree;
GtkCTreeNode *node;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
-
+
if (GTK_CLIST_AUTO_SORT (clist))
return;
-
+
if (source_row < 0 || source_row >= clist->rows ||
dest_row < 0 || dest_row >= clist->rows ||
source_row == dest_row)
return;
-
+
ctree = GTK_CTREE (clist);
node = GTK_CTREE_NODE (g_list_nth (clist->row_list, source_row));
-
+
if (source_row < dest_row)
{
GtkCTreeNode *work;
-
+
dest_row++;
work = GTK_CTREE_ROW (node)->children;
-
+
while (work && GTK_CTREE_ROW (work)->level > GTK_CTREE_ROW (node)->level)
{
work = GTK_CTREE_NODE_NEXT (work);
dest_row++;
}
-
+
if (dest_row > clist->rows)
dest_row = clist->rows;
}
-
+
if (dest_row < clist->rows)
{
GtkCTreeNode *sibling;
-
+
sibling = GTK_CTREE_NODE (g_list_nth (clist->row_list, dest_row));
gtk_ctree_move (ctree, node, GTK_CTREE_ROW (sibling)->parent, sibling);
}
GtkCList *clist;
GtkCTreeNode *work;
gboolean visible = FALSE;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (node != NULL);
g_return_if_fail (!new_sibling ||
GTK_CTREE_ROW (new_sibling)->parent == new_parent);
-
+
if (new_parent && GTK_CTREE_ROW (new_parent)->is_leaf)
return;
-
+
/* new_parent != child of child */
for (work = new_parent; work; work = GTK_CTREE_ROW (work)->parent)
if (work == node)
return;
-
+
clist = GTK_CLIST (ctree);
-
+
visible = gtk_ctree_is_viewable (ctree, node);
-
+
if (clist->selection_mode == GTK_SELECTION_EXTENDED)
{
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
clist->undo_selection = NULL;
clist->undo_unselection = NULL;
}
-
+
if (GTK_CLIST_AUTO_SORT (clist))
{
if (new_parent == GTK_CTREE_ROW (node)->parent)
new_sibling = GTK_CTREE_ROW (new_parent)->children;
else
new_sibling = GTK_CTREE_NODE (clist->row_list);
-
+
while (new_sibling && clist->compare
(clist, GTK_CTREE_ROW (node), GTK_CTREE_ROW (new_sibling)) > 0)
new_sibling = GTK_CTREE_ROW (new_sibling)->sibling;
}
-
+
if (new_parent == GTK_CTREE_ROW (node)->parent &&
new_sibling == GTK_CTREE_ROW (node)->sibling)
return;
-
+
gtk_clist_freeze (clist);
-
+
work = NULL;
if (gtk_ctree_is_viewable (ctree, node) ||
gtk_ctree_is_viewable (ctree, new_sibling))
work = GTK_CTREE_NODE (g_list_nth (clist->row_list, clist->focus_row));
-
+
gtk_ctree_unlink (ctree, node, FALSE);
gtk_ctree_link (ctree, node, new_parent, new_sibling, FALSE);
clist->focus_row = g_list_position (clist->row_list, (GList *)work);
clist->undo_anchor = clist->focus_row;
}
-
+
if (clist->column[ctree->tree_column].auto_resize &&
!GTK_CLIST_AUTO_RESIZE_BLOCKED (clist) &&
(visible || gtk_ctree_is_viewable (ctree, node)))
gtk_clist_set_column_width
(clist, ctree->tree_column,
gtk_clist_optimal_column_width (clist, ctree->tree_column));
-
+
gtk_clist_thaw (clist);
}
{
GtkCList *clist;
GtkCTreeNode *node;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
-
+
clist = GTK_CLIST (ctree);
-
+
if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (ctree))
return;
GTK_CTREE_NODE (g_list_nth (clist->row_list, clist->focus_row))) ||
GTK_CTREE_ROW (node)->is_leaf || !(GTK_CTREE_ROW (node)->children))
return;
-
+
switch (action)
{
case GTK_CTREE_EXPANSION_EXPAND:
GtkRequisition requisition;
gboolean visible;
gint level;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
-
+
if (!node || GTK_CTREE_ROW (node)->expanded || GTK_CTREE_ROW (node)->is_leaf)
return;
-
+
clist = GTK_CLIST (ctree);
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
-
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
+
GTK_CTREE_ROW (node)->expanded = TRUE;
level = GTK_CTREE_ROW (node)->level;
-
+
visible = gtk_ctree_is_viewable (ctree, node);
/* get cell width if tree_column is auto resized */
if (visible && clist->column[ctree->tree_column].auto_resize &&
!GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
- GTK_CLIST_CLASS_FW (clist)->cell_size_request
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request
(clist, >K_CTREE_ROW (node)->row, ctree->tree_column, &requisition);
-
+
/* unref/unset closed pixmap */
if (GTK_CELL_PIXTEXT
(GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap)
(GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask = NULL;
}
}
-
+
/* set/ref opened pixmap */
if (GTK_CTREE_ROW (node)->pixmap_opened)
{
GTK_CELL_PIXTEXT
(GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap =
gdk_pixmap_ref (GTK_CTREE_ROW (node)->pixmap_opened);
-
+
if (GTK_CTREE_ROW (node)->mask_opened)
GTK_CELL_PIXTEXT
(GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask =
gdk_pixmap_ref (GTK_CTREE_ROW (node)->mask_opened);
}
-
-
+
+
work = GTK_CTREE_ROW (node)->children;
if (work)
{
{
cell_width = g_new0 (gint, clist->columns);
if (clist->column[ctree->tree_column].auto_resize)
- cell_width[ctree->tree_column] = requisition.width;
-
+ cell_width[ctree->tree_column] = requisition.width;
+
while (work)
{
/* search maximum cell widths of auto_resize columns */
for (i = 0; i < clist->columns; i++)
if (clist->column[i].auto_resize)
{
- GTK_CLIST_CLASS_FW (clist)->cell_size_request
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request
(clist, >K_CTREE_ROW (work)->row, i, &requisition);
cell_width[i] = MAX (requisition.width, cell_width[i]);
}
-
+
list = (GList *)work;
work = GTK_CTREE_NODE_NEXT (work);
tmp++;
work = GTK_CTREE_NODE_NEXT (work);
tmp++;
}
-
+
list->next = (GList *)GTK_CTREE_NODE_NEXT (node);
-
+
if (GTK_CTREE_NODE_NEXT (node))
{
GList *tmp_list;
-
+
tmp_list = (GList *)GTK_CTREE_NODE_NEXT (node);
tmp_list->prev = list;
}
else
clist->row_list_end = list;
-
+
list = (GList *)node;
list->next = (GList *)(GTK_CTREE_ROW (node)->children);
-
+
if (visible)
{
/* resize auto_resize columns if needed */
cell_width[i] > clist->column[i].width)
gtk_clist_set_column_width (clist, i, cell_width[i]);
g_free (cell_width);
-
+
/* update focus_row position */
row = g_list_position (clist->row_list, (GList *)node);
if (row < clist->focus_row)
clist->focus_row += tmp;
-
+
clist->rows += tmp;
CLIST_REFRESH (clist);
}
GtkRequisition requisition;
gboolean visible;
gint level;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
-
+
if (!node || !GTK_CTREE_ROW (node)->expanded ||
GTK_CTREE_ROW (node)->is_leaf)
return;
-
+
clist = GTK_CLIST (ctree);
-
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
GTK_CTREE_ROW (node)->expanded = FALSE;
level = GTK_CTREE_ROW (node)->level;
-
+
visible = gtk_ctree_is_viewable (ctree, node);
/* get cell width if tree_column is auto resized */
if (visible && clist->column[ctree->tree_column].auto_resize &&
!GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
- GTK_CLIST_CLASS_FW (clist)->cell_size_request
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request
(clist, >K_CTREE_ROW (node)->row, ctree->tree_column, &requisition);
-
+
/* unref/unset opened pixmap */
if (GTK_CELL_PIXTEXT
(GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap)
(GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask = NULL;
}
}
-
+
/* set/ref closed pixmap */
if (GTK_CTREE_ROW (node)->pixmap_closed)
{
GTK_CELL_PIXTEXT
(GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap =
gdk_pixmap_ref (GTK_CTREE_ROW (node)->pixmap_closed);
-
+
if (GTK_CTREE_ROW (node)->mask_closed)
GTK_CELL_PIXTEXT
(GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask =
gdk_pixmap_ref (GTK_CTREE_ROW (node)->mask_closed);
}
-
+
work = GTK_CTREE_ROW (node)->children;
if (work)
{
gint tmp = 0;
gint row;
GList *list;
-
+
while (work && GTK_CTREE_ROW (work)->level > level)
{
work = GTK_CTREE_NODE_NEXT (work);
tmp++;
}
-
+
if (work)
{
list = (GList *)node;
list->next = NULL;
clist->row_list_end = (GList *)node;
}
-
+
if (visible)
{
/* resize auto_resize columns if needed */
auto_resize_columns (clist);
-
+
row = g_list_position (clist->row_list, (GList *)node);
if (row < clist->focus_row)
clist->focus_row -= tmp;
/* resize tree_column if needed */
column_auto_resize (clist, >K_CTREE_ROW (node)->row, ctree->tree_column,
requisition.width);
-
+
}
static void
{
/* resize column if needed for auto_resize */
GtkRequisition requisition;
-
+
if (!clist->column[column].auto_resize ||
GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
return;
-
+
if (clist_row)
- GTK_CLIST_CLASS_FW (clist)->cell_size_request (clist, clist_row,
- column, &requisition);
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
+ column, &requisition);
else
requisition.width = 0;
-
+
if (requisition.width > clist->column[column].width)
gtk_clist_set_column_width (clist, column, requisition.width);
else if (requisition.width < old_width &&
{
GList *list;
gint new_width;
-
+
/* run a "gtk_clist_optimal_column_width" but break, if
* the column doesn't shrink */
if (GTK_CLIST_SHOW_TITLES (clist) && clist->column[column].button)
(CELL_SPACING + (2 * COLUMN_INSET)));
else
new_width = 0;
-
+
for (list = clist->row_list; list; list = list->next)
{
- GTK_CLIST_CLASS_FW (clist)->cell_size_request
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request
(clist, GTK_CLIST_ROW (list), column, &requisition);
new_width = MAX (new_width, requisition.width);
if (new_width == clist->column[column].width)
auto_resize_columns (GtkCList *clist)
{
gint i;
-
+
if (GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
return;
-
+
for (i = 0; i < clist->columns; i++)
column_auto_resize (clist, NULL, i, clist->column[i].width);
}
GtkStyle *style;
gint width;
gint height;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
g_return_if_fail (requisition != NULL);
-
+
ctree = GTK_CTREE (clist);
-
+
get_cell_style (clist, clist_row, GTK_STATE_NORMAL, column, &style,
NULL, NULL);
-
+
switch (clist_row->cell[column].type)
{
case GTK_CELL_TEXT:
}
else
width = height = 0;
-
+
requisition->width = width +
gdk_string_width (style->font,
GTK_CELL_TEXT (clist_row->cell[column])->text);
-
+
requisition->height = MAX (style->font->ascent + style->font->descent,
height);
if (column == ctree->tree_column)
requisition->height = 0;
break;
}
-
+
requisition->width += clist_row->cell[column].horizontal;
requisition->height += clist_row->cell[column].vertical;
}
gboolean visible = FALSE;
GtkCTree *ctree;
GtkRequisition requisition;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
g_return_if_fail (clist_row != NULL);
-
+
ctree = GTK_CTREE (clist);
-
+
if (clist->column[column].auto_resize &&
!GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
{
GtkCTreeNode *parent;
-
+
parent = ((GtkCTreeRow *)clist_row)->parent;
if (!parent || (parent && GTK_CTREE_ROW (parent)->expanded &&
gtk_ctree_is_viewable (ctree, parent)))
{
visible = TRUE;
- GTK_CLIST_CLASS_FW (clist)->cell_size_request (clist, clist_row,
- column, &requisition);
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
+ column, &requisition);
}
}
-
+
switch (clist_row->cell[column].type)
{
case GTK_CELL_EMPTY:
default:
break;
}
-
+
clist_row->cell[column].type = GTK_CELL_EMPTY;
if (column == ctree->tree_column && type != GTK_CELL_EMPTY)
type = GTK_CELL_PIXTEXT;
-
+
switch (type)
{
case GTK_CELL_TEXT:
if (GTK_CTREE_ROW (node)->mask_closed)
gdk_bitmap_unref (GTK_CTREE_ROW (node)->mask_closed);
}
-
+
GTK_CTREE_ROW (node)->pixmap_opened = NULL;
GTK_CTREE_ROW (node)->mask_opened = NULL;
GTK_CTREE_ROW (node)->pixmap_closed = NULL;
GTK_CTREE_ROW (node)->mask_closed = NULL;
-
+
if (pixmap_closed)
{
GTK_CTREE_ROW (node)->pixmap_closed = gdk_pixmap_ref (pixmap_closed);
if (mask_opened)
GTK_CTREE_ROW (node)->mask_opened = gdk_bitmap_ref (mask_opened);
}
-
+
GTK_CTREE_ROW (node)->is_leaf = is_leaf;
GTK_CTREE_ROW (node)->expanded = (is_leaf) ? FALSE : expanded;
-
+
if (GTK_CTREE_ROW (node)->expanded)
gtk_ctree_node_set_pixtext (ctree, node, ctree->tree_column,
text, spacing, pixmap_opened, mask_opened);
{
if (!node)
return;
-
+
if (GTK_CTREE_ROW (node)->parent)
- GTK_CTREE_ROW (node)->level =
- GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->level + 1;
+ GTK_CTREE_ROW (node)->level =
+ GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->level + 1;
else
- GTK_CTREE_ROW (node)->level = 1;
+ GTK_CTREE_ROW (node)->level = 1;
}
static void
{
if (!node)
return;
-
+
if (GTK_CTREE_ROW (node)->expanded)
gtk_signal_emit (GTK_OBJECT (ctree), ctree_signals[TREE_COLLAPSE], node);
else
GtkCList *clist;
GtkCTreeRow *ctree_row;
int i;
-
+
clist = GTK_CLIST (ctree);
ctree_row = g_chunk_new (GtkCTreeRow, clist->row_mem_chunk);
ctree_row->row.cell = g_chunk_new (GtkCell, clist->cell_mem_chunk);
-
+
for (i = 0; i < clist->columns; i++)
{
ctree_row->row.cell[i].type = GTK_CELL_EMPTY;
ctree_row->row.cell[i].horizontal = 0;
ctree_row->row.cell[i].style = NULL;
}
-
+
GTK_CELL_PIXTEXT (ctree_row->row.cell[ctree->tree_column])->text = NULL;
-
+
ctree_row->row.fg_set = FALSE;
ctree_row->row.bg_set = FALSE;
ctree_row->row.style = NULL;
ctree_row->row.state = GTK_STATE_NORMAL;
ctree_row->row.data = NULL;
ctree_row->row.destroy = NULL;
-
+
ctree_row->level = 0;
ctree_row->expanded = FALSE;
ctree_row->parent = NULL;
{
GtkCList *clist;
gint i;
-
+
clist = GTK_CLIST (ctree);
-
+
for (i = 0; i < clist->columns; i++)
{
- GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ GTK_CLIST_GET_CLASS (clist)->set_cell_contents
(clist, &(ctree_row->row), i, GTK_CELL_EMPTY, NULL, 0, NULL, NULL);
if (ctree_row->row.cell[i].style)
{
gtk_style_unref (ctree_row->row.cell[i].style);
}
}
-
+
if (ctree_row->row.style)
{
if (GTK_WIDGET_REALIZED (ctree))
gtk_style_detach (ctree_row->row.style);
gtk_style_unref (ctree_row->row.style);
}
-
+
if (ctree_row->pixmap_closed)
{
gdk_pixmap_unref (ctree_row->pixmap_closed);
if (ctree_row->mask_closed)
gdk_bitmap_unref (ctree_row->mask_closed);
}
-
+
if (ctree_row->pixmap_opened)
{
gdk_pixmap_unref (ctree_row->pixmap_opened);
if (ctree_row->mask_opened)
gdk_bitmap_unref (ctree_row->mask_opened);
}
-
+
if (ctree_row->row.destroy)
{
GtkDestroyNotify dnotify = ctree_row->row.destroy;
gpointer ddata = ctree_row->row.data;
-
+
ctree_row->row.destroy = NULL;
ctree_row->row.data = NULL;
-
+
dnotify (ddata);
}
-
+
g_mem_chunk_free (clist->cell_mem_chunk, ctree_row->row.cell);
g_mem_chunk_free (clist->row_mem_chunk, ctree_row);
}
GdkEvent *event)
{
GList *node;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
GdkEvent *event)
{
GList *node;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
-
+
if ((node = g_list_nth (clist->row_list, row)))
gtk_signal_emit (GTK_OBJECT (clist), ctree_signals[TREE_UNSELECT_ROW],
node, column);
GList *list;
GtkCTreeNode *sel_row;
gboolean node_selected;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
-
+
if (!node || GTK_CTREE_ROW (node)->row.state == GTK_STATE_SELECTED ||
!GTK_CTREE_ROW (node)->row.selectable)
return;
-
+
clist = GTK_CLIST (ctree);
-
+
switch (clist->selection_mode)
{
case GTK_SELECTION_SINGLE:
case GTK_SELECTION_BROWSE:
-
+
node_selected = FALSE;
list = clist->selection;
-
+
while (list)
{
sel_row = list->data;
gtk_signal_emit (GTK_OBJECT (ctree),
ctree_signals[TREE_UNSELECT_ROW], sel_row, column);
}
-
+
if (node_selected)
return;
-
+
default:
break;
}
-
+
GTK_CTREE_ROW (node)->row.state = GTK_STATE_SELECTED;
-
+
if (!clist->selection)
{
clist->selection = g_list_append (clist->selection, node);
}
else
clist->selection_end = g_list_append (clist->selection_end, node)->next;
-
+
tree_draw_node (ctree, node);
}
gint column)
{
GtkCList *clist;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
-
+
if (!node || GTK_CTREE_ROW (node)->row.state != GTK_STATE_SELECTED)
return;
-
+
clist = GTK_CLIST (ctree);
-
+
if (clist->selection_end && clist->selection_end->data == node)
clist->selection_end = clist->selection_end->prev;
-
+
clist->selection = g_list_remove (clist->selection, node);
GTK_CTREE_ROW (node)->row.state = GTK_STATE_NORMAL;
-
+
tree_draw_node (ctree, node);
}
if (!node || GTK_CTREE_ROW (node)->row.state == GTK_STATE_SELECTED ||
!GTK_CTREE_ROW (node)->row.selectable)
return;
-
+
GTK_CLIST (ctree)->undo_unselection =
g_list_prepend (GTK_CLIST (ctree)->undo_unselection, node);
gtk_ctree_select (ctree, node);
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
-
+
ctree = GTK_CTREE (clist);
-
+
switch (clist->selection_mode)
{
case GTK_SELECTION_SINGLE:
case GTK_SELECTION_BROWSE:
return;
-
+
case GTK_SELECTION_EXTENDED:
-
+
gtk_clist_freeze (clist);
-
+
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
clist->undo_selection = NULL;
clist->undo_unselection = NULL;
-
+
clist->anchor_state = GTK_STATE_SELECTED;
clist->anchor = -1;
clist->drag_pos = -1;
clist->undo_anchor = clist->focus_row;
-
+
for (node = GTK_CTREE_NODE (clist->row_list); node;
node = GTK_CTREE_NODE_NEXT (node))
gtk_ctree_pre_recursive (ctree, node, select_row_recursive, NULL);
-
+
gtk_clist_thaw (clist);
break;
-
+
case GTK_SELECTION_MULTIPLE:
gtk_ctree_select_recursive (ctree, NULL);
break;
-
+
default:
/* do nothing */
break;
GtkCTree *ctree;
GtkCTreeNode *node;
GList *list;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
ctree = GTK_CTREE (clist);
-
+
switch (clist->selection_mode)
{
case GTK_SELECTION_BROWSE:
return;
}
break;
-
+
case GTK_SELECTION_EXTENDED:
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
clist->undo_selection = NULL;
clist->undo_unselection = NULL;
-
+
clist->anchor = -1;
clist->drag_pos = -1;
clist->undo_anchor = clist->focus_row;
break;
-
+
default:
break;
}
-
+
list = clist->selection;
-
+
while (list)
{
node = list->data;
g_return_val_if_fail (ctree != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
g_return_val_if_fail (node != NULL, FALSE);
-
+
clist = GTK_CLIST (ctree);
-
+
if (!clist->column[ctree->tree_column].visible ||
ctree->expander_style == GTK_CTREE_EXPANDER_NONE)
return FALSE;
-
+
tree_row = GTK_CTREE_ROW (node);
-
+
cell = GTK_CELL_PIXTEXT(tree_row->row.cell[ctree->tree_column]);
-
+
yu = (ROW_TOP_YPIXEL (clist, row) + (clist->row_height - PM_SIZE) / 2 -
(clist->row_height - 1) % 2);
-
+
if (clist->column[ctree->tree_column].justification == GTK_JUSTIFY_RIGHT)
xl = (clist->column[ctree->tree_column].area.x +
clist->column[ctree->tree_column].area.width - 1 + clist->hoffset -
xl = (clist->column[ctree->tree_column].area.x + clist->hoffset +
(tree_row->level - 1) * ctree->tree_indent +
(ctree->line_style == GTK_CTREE_LINES_TABBED) * 3);
-
+
return (x >= xl && x <= xl + PM_SIZE && y >= yu && y <= yu + PM_SIZE);
}
gchar *titles[])
{
GtkCList *clist;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (GTK_OBJECT_CONSTRUCTED (ctree) == FALSE);
-
+
clist = GTK_CLIST (ctree);
-
+
clist->row_mem_chunk = g_mem_chunk_new ("ctree row mem chunk",
sizeof (GtkCTreeRow),
sizeof (GtkCTreeRow)
* CLIST_OPTIMUM_SIZE,
G_ALLOC_AND_FREE);
-
+
clist->cell_mem_chunk = g_mem_chunk_new ("ctree cell mem chunk",
sizeof (GtkCell) * columns,
sizeof (GtkCell) * columns
* CLIST_OPTIMUM_SIZE,
G_ALLOC_AND_FREE);
-
+
ctree->tree_column = tree_column;
-
+
gtk_clist_construct (clist, columns, titles);
}
gchar *titles[])
{
GtkWidget *widget;
-
+
g_return_val_if_fail (columns > 0, NULL);
g_return_val_if_fail (tree_column >= 0 && tree_column < columns, NULL);
-
+
widget = gtk_type_new (GTK_TYPE_CTREE);
gtk_ctree_construct (GTK_CTREE (widget), columns, tree_column, titles);
-
+
return widget;
}
GtkCTreeNode *parent = NULL;
GtkCTreeNode *sibling;
GtkCTreeNode *node;
-
+
g_return_val_if_fail (clist != NULL, -1);
g_return_val_if_fail (GTK_IS_CTREE (clist), -1);
-
+
sibling = GTK_CTREE_NODE (g_list_nth (clist->row_list, row));
if (sibling)
parent = GTK_CTREE_ROW (sibling)->parent;
-
+
node = gtk_ctree_insert_node (GTK_CTREE (clist), parent, sibling, text, 5,
NULL, NULL, NULL, NULL, TRUE, FALSE);
-
+
if (GTK_CLIST_AUTO_SORT (clist) || !sibling)
return g_list_position (clist->row_list, (GList *) node);
GtkCTreeNode *node;
GList *list;
gint i;
-
+
g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
if (sibling)
g_return_val_if_fail (GTK_CTREE_ROW (sibling)->parent == parent, NULL);
-
+
if (parent && GTK_CTREE_ROW (parent)->is_leaf)
return NULL;
-
+
clist = GTK_CLIST (ctree);
-
+
/* create the row */
new_row = row_new (ctree);
list = g_list_alloc ();
list->data = new_row;
node = GTK_CTREE_NODE (list);
-
+
if (text)
for (i = 0; i < clist->columns; i++)
if (text[i] && i != ctree->tree_column)
- GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ GTK_CLIST_GET_CLASS (clist)->set_cell_contents
(clist, &(new_row->row), i, GTK_CELL_TEXT, text[i], 0, NULL, NULL);
-
+
set_node_info (ctree, node, text ?
text[ctree->tree_column] : NULL, spacing, pixmap_closed,
mask_closed, pixmap_opened, mask_opened, is_leaf, expanded);
-
+
/* sorted insertion */
if (GTK_CLIST_AUTO_SORT (clist))
{
sibling = GTK_CTREE_ROW (parent)->children;
else
sibling = GTK_CTREE_NODE (clist->row_list);
-
+
while (sibling && clist->compare
(clist, GTK_CTREE_ROW (node), GTK_CTREE_ROW (sibling)) > 0)
sibling = GTK_CTREE_ROW (sibling)->sibling;
}
-
+
gtk_ctree_link (ctree, node, parent, sibling, TRUE);
-
+
if (text && !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist) &&
gtk_ctree_is_viewable (ctree, node))
{
if (clist->column[i].auto_resize)
column_auto_resize (clist, &(new_row->row), i, 0);
}
-
+
if (clist->rows == 1)
{
clist->focus_row = 0;
if (clist->selection_mode == GTK_SELECTION_BROWSE)
gtk_ctree_select (ctree, node);
}
-
-
+
+
CLIST_REFRESH (clist);
-
+
return node;
}
GList *list;
GNode *work;
guint depth = 1;
-
+
g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
g_return_val_if_fail (gnode != NULL, NULL);
g_return_val_if_fail (GTK_CTREE_ROW (sibling)->parent == parent, NULL);
clist = GTK_CLIST (ctree);
-
+
if (parent)
depth = GTK_CTREE_ROW (parent)->level + 1;
-
+
list = g_list_alloc ();
list->data = row_new (ctree);
cnode = GTK_CTREE_NODE (list);
-
+
gtk_clist_freeze (clist);
-
+
set_node_info (ctree, cnode, "", 0, NULL, NULL, NULL, NULL, TRUE, FALSE);
-
+
if (!func (ctree, depth, gnode, cnode, data))
{
tree_delete_row (ctree, cnode, NULL);
return NULL;
}
-
+
if (GTK_CLIST_AUTO_SORT (clist))
{
if (parent)
sibling = GTK_CTREE_ROW (parent)->children;
else
sibling = GTK_CTREE_NODE (clist->row_list);
-
+
while (sibling && clist->compare
(clist, GTK_CTREE_ROW (cnode), GTK_CTREE_ROW (sibling)) > 0)
sibling = GTK_CTREE_ROW (sibling)->sibling;
}
-
+
gtk_ctree_link (ctree, cnode, parent, sibling, TRUE);
-
+
for (work = g_node_last_child (gnode); work; work = work->prev)
{
new_child = gtk_ctree_insert_gnode (ctree, cnode, child,
}
gtk_clist_thaw (clist);
-
+
return cnode;
}
GtkCTreeNode *work;
GNode *gnode;
gint depth;
-
+
g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
g_return_val_if_fail (node != NULL, NULL);
g_return_val_if_fail (parent != NULL, NULL);
g_return_val_if_fail (sibling->parent == parent, NULL);
}
-
+
gnode = g_node_new (NULL);
depth = g_node_depth (parent) + 1;
g_node_destroy (gnode);
return NULL;
}
-
+
if (parent)
g_node_insert_before (parent, sibling, gnode);
-
+
if (!GTK_CTREE_ROW (node)->is_leaf)
{
GNode *new_sibling = NULL;
-
+
for (work = GTK_CTREE_ROW (node)->children; work;
work = GTK_CTREE_ROW (work)->sibling)
new_sibling = gtk_ctree_export_to_gnode (ctree, gnode, new_sibling,
work, func, data);
-
+
g_node_reverse_children (gnode);
}
-
+
return gnode;
}
-
+
static void
real_remove_row (GtkCList *clist,
gint row)
{
GtkCTreeNode *node;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
-
+
node = GTK_CTREE_NODE (g_list_nth (clist->row_list, row));
-
+
if (node)
gtk_ctree_remove_node (GTK_CTREE (clist), node);
}
GtkCTreeNode *node)
{
GtkCList *clist;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
-
+
clist = GTK_CLIST (ctree);
-
+
gtk_clist_freeze (clist);
-
+
if (node)
{
gboolean visible;
-
+
visible = gtk_ctree_is_viewable (ctree, node);
gtk_ctree_unlink (ctree, node, TRUE);
gtk_ctree_post_recursive (ctree, node, GTK_CTREE_FUNC (tree_delete),
if (clist->selection_mode == GTK_SELECTION_BROWSE && !clist->selection &&
clist->focus_row >= 0)
gtk_clist_select_row (clist, clist->focus_row, -1);
-
+
auto_resize_columns (clist);
}
else
gtk_clist_clear (clist);
-
+
gtk_clist_thaw (clist);
}
GtkCTree *ctree;
GtkCTreeNode *work;
GtkCTreeNode *ptr;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
-
+
ctree = GTK_CTREE (clist);
-
+
/* remove all rows */
work = GTK_CTREE_NODE (clist->row_list);
clist->row_list = NULL;
clist->row_list_end = NULL;
-
+
GTK_CLIST_SET_FLAG (clist, CLIST_AUTO_RESIZE_BLOCKED);
while (work)
{
NULL);
}
GTK_CLIST_UNSET_FLAG (clist, CLIST_AUTO_RESIZE_BLOCKED);
-
+
parent_class->clear (clist);
}
{
GtkCTreeNode *work;
GtkCTreeNode *tmp;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (func != NULL);
-
+
if (node)
work = GTK_CTREE_ROW (node)->children;
else
work = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
-
+
while (work)
{
tmp = GTK_CTREE_ROW (work)->sibling;
gtk_ctree_post_recursive (ctree, work, func, data);
work = tmp;
}
-
+
if (node)
func (ctree, node, data);
}
{
GtkCTreeNode *work;
GtkCTreeNode *tmp;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (func != NULL);
-
+
if (depth < 0)
{
gtk_ctree_post_recursive (ctree, node, func, data);
return;
}
-
+
if (node)
work = GTK_CTREE_ROW (node)->children;
else
work = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
-
+
if (work && GTK_CTREE_ROW (work)->level <= depth)
{
while (work)
work = tmp;
}
}
-
+
if (node && GTK_CTREE_ROW (node)->level <= depth)
func (ctree, node, data);
}
{
GtkCTreeNode *work;
GtkCTreeNode *tmp;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (func != NULL);
-
+
if (node)
{
work = GTK_CTREE_ROW (node)->children;
}
else
work = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
-
+
while (work)
{
tmp = GTK_CTREE_ROW (work)->sibling;
{
GtkCTreeNode *work;
GtkCTreeNode *tmp;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (func != NULL);
-
+
if (depth < 0)
{
gtk_ctree_pre_recursive (ctree, node, func, data);
return;
}
-
+
if (node)
{
work = GTK_CTREE_ROW (node)->children;
}
else
work = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
-
+
if (work && GTK_CTREE_ROW (work)->level <= depth)
{
while (work)
GtkCTreeNode *node)
{
GtkCTreeRow *work;
-
+
g_return_val_if_fail (ctree != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
g_return_val_if_fail (node != NULL, FALSE);
-
+
work = GTK_CTREE_ROW (node);
-
+
while (work->parent && GTK_CTREE_ROW (work->parent)->expanded)
work = GTK_CTREE_ROW (work->parent);
-
+
if (!work->parent)
return TRUE;
-
+
return FALSE;
}
{
g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
-
+
if (!node)
return NULL;
-
+
while (GTK_CTREE_ROW (node)->sibling)
node = GTK_CTREE_ROW (node)->sibling;
node = GTK_CTREE_ROW(ctree_row->parent)->children;
else
node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
-
+
while (GTK_CTREE_ROW (node) != ctree_row)
node = GTK_CTREE_ROW (node)->sibling;
{
g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
-
+
if ((row < 0) || (row >= GTK_CLIST(ctree)->rows))
return NULL;
-
+
return GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list, row));
}
{
if (!child)
return FALSE;
-
+
if (!node)
node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
-
+
while (node)
{
if (node == child)
{
g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
g_return_val_if_fail (node != NULL, FALSE);
-
+
if (GTK_CTREE_ROW (node)->children)
return gtk_ctree_find (ctree, GTK_CTREE_ROW (node)->children, child);
-
+
return FALSE;
}
gpointer data)
{
GList *list = NULL;
-
+
g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
-
+
/* if node == NULL then look in the whole tree */
if (!node)
node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
-
+
while (node)
{
if (GTK_CTREE_ROW (node)->row.data == data)
list = g_list_append (list, node);
-
+
if (GTK_CTREE_ROW (node)->children)
{
GList *sub_list;
-
+
sub_list = gtk_ctree_find_all_by_row_data (ctree,
GTK_CTREE_ROW
(node)->children,
GCompareFunc func)
{
GtkCTreeNode *work;
-
+
g_return_val_if_fail (func != NULL, NULL);
-
+
if (!node)
node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
-
+
while (node)
{
if (!func (GTK_CTREE_ROW (node)->row.data, data))
GCompareFunc func)
{
GList *list = NULL;
-
+
g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
g_return_val_if_fail (func != NULL, NULL);
-
+
/* if node == NULL then look in the whole tree */
if (!node)
node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
-
+
while (node)
{
if (!func (GTK_CTREE_ROW (node)->row.data, data))
list = g_list_append (list, node);
-
+
if (GTK_CTREE_ROW (node)->children)
{
GList *sub_list;
-
+
sub_list = gtk_ctree_find_all_by_row_data_custom (ctree,
GTK_CTREE_ROW
(node)->children,
g_return_val_if_fail (ctree != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
-
+
if (gtk_clist_get_selection_info (GTK_CLIST (ctree), x, y, &row, &column))
if ((node = GTK_CTREE_NODE(g_list_nth (GTK_CLIST (ctree)->row_list, row))))
return ctree_is_hot_spot (ctree, node, row, x, y);
-
+
return FALSE;
}
if (GTK_CTREE_ROW (node)->is_leaf)
return;
-
+
gtk_signal_emit (GTK_OBJECT (ctree), ctree_signals[TREE_EXPAND], node);
}
{
GtkCList *clist;
gboolean thaw = FALSE;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
-
+
clist = GTK_CLIST (ctree);
-
+
if (node && GTK_CTREE_ROW (node)->is_leaf)
return;
-
+
if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
{
gtk_clist_freeze (clist);
thaw = TRUE;
}
-
+
gtk_ctree_post_recursive (ctree, node, GTK_CTREE_FUNC (tree_expand), NULL);
-
+
if (thaw)
gtk_clist_thaw (clist);
}
{
GtkCList *clist;
gboolean thaw = FALSE;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
-
+
clist = GTK_CLIST (ctree);
-
+
if (node && GTK_CTREE_ROW (node)->is_leaf)
return;
-
+
if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
{
gtk_clist_freeze (clist);
thaw = TRUE;
}
-
+
gtk_ctree_post_recursive_to_depth (ctree, node, depth,
GTK_CTREE_FUNC (tree_expand), NULL);
-
+
if (thaw)
gtk_clist_thaw (clist);
}
if (GTK_CTREE_ROW (node)->is_leaf)
return;
-
+
gtk_signal_emit (GTK_OBJECT (ctree), ctree_signals[TREE_COLLAPSE], node);
}
GtkCList *clist;
gboolean thaw = FALSE;
gint i;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
-
+
if (node && GTK_CTREE_ROW (node)->is_leaf)
return;
-
+
clist = GTK_CLIST (ctree);
-
+
if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
{
gtk_clist_freeze (clist);
thaw = TRUE;
}
-
+
GTK_CLIST_SET_FLAG (clist, CLIST_AUTO_RESIZE_BLOCKED);
gtk_ctree_post_recursive (ctree, node, GTK_CTREE_FUNC (tree_collapse), NULL);
GTK_CLIST_UNSET_FLAG (clist, CLIST_AUTO_RESIZE_BLOCKED);
if (clist->column[i].auto_resize)
gtk_clist_set_column_width (clist, i,
gtk_clist_optimal_column_width (clist, i));
-
+
if (thaw)
gtk_clist_thaw (clist);
}
GtkCList *clist;
gboolean thaw = FALSE;
gint i;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
-
+
if (node && GTK_CTREE_ROW (node)->is_leaf)
return;
-
+
clist = GTK_CLIST (ctree);
-
+
if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
{
gtk_clist_freeze (clist);
thaw = TRUE;
}
-
+
GTK_CLIST_SET_FLAG (clist, CLIST_AUTO_RESIZE_BLOCKED);
gtk_ctree_post_recursive_to_depth (ctree, node, depth,
GTK_CTREE_FUNC (tree_collapse_to_depth),
if (clist->column[i].auto_resize)
gtk_clist_set_column_width (clist, i,
gtk_clist_optimal_column_width (clist, i));
-
+
if (thaw)
gtk_clist_thaw (clist);
}
if (GTK_CTREE_ROW (node)->is_leaf)
return;
-
+
tree_toggle_expansion (ctree, node, NULL);
}
{
GtkCList *clist;
gboolean thaw = FALSE;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
if (node && GTK_CTREE_ROW (node)->is_leaf)
return;
-
+
clist = GTK_CLIST (ctree);
-
+
if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
{
gtk_clist_freeze (clist);
gtk_ctree_post_recursive (ctree, node,
GTK_CTREE_FUNC (tree_toggle_expansion), NULL);
-
+
if (thaw)
gtk_clist_thaw (clist);
}
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
-
+
if (GTK_CTREE_ROW (node)->row.selectable)
gtk_signal_emit (GTK_OBJECT (ctree), ctree_signals[TREE_SELECT_ROW],
node, -1);
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
-
+
gtk_signal_emit (GTK_OBJECT (ctree), ctree_signals[TREE_UNSELECT_ROW],
node, -1);
}
{
GtkCList *clist;
gboolean thaw = FALSE;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
-
+
clist = GTK_CLIST (ctree);
-
+
if ((state &&
(clist->selection_mode == GTK_SELECTION_BROWSE ||
clist->selection_mode == GTK_SELECTION_SINGLE)) ||
(!state && clist->selection_mode == GTK_SELECTION_BROWSE))
return;
-
+
if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
{
gtk_clist_freeze (clist);
thaw = TRUE;
}
-
+
if (clist->selection_mode == GTK_SELECTION_EXTENDED)
{
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
clist->undo_selection = NULL;
clist->undo_unselection = NULL;
}
-
+
if (state)
gtk_ctree_post_recursive (ctree, node,
GTK_CTREE_FUNC (tree_select), NULL);
const gchar *text)
{
GtkCList *clist;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
-
+
if (column < 0 || column >= GTK_CLIST (ctree)->columns)
return;
clist = GTK_CLIST (ctree);
-
- GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+
+ GTK_CLIST_GET_CLASS (clist)->set_cell_contents
(clist, &(GTK_CTREE_ROW(node)->row), column, GTK_CELL_TEXT,
text, 0, NULL, NULL);
-
+
tree_draw_node (ctree, node);
}
GdkBitmap *mask)
{
GtkCList *clist;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
g_return_if_fail (pixmap != NULL);
-
+
if (column < 0 || column >= GTK_CLIST (ctree)->columns)
return;
-
+
gdk_pixmap_ref (pixmap);
if (mask)
gdk_pixmap_ref (mask);
-
+
clist = GTK_CLIST (ctree);
-
- GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+
+ GTK_CLIST_GET_CLASS (clist)->set_cell_contents
(clist, &(GTK_CTREE_ROW (node)->row), column, GTK_CELL_PIXMAP,
NULL, 0, pixmap, mask);
-
+
tree_draw_node (ctree, node);
}
GdkBitmap *mask)
{
GtkCList *clist;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
g_return_if_fail (pixmap != NULL);
if (column < 0 || column >= GTK_CLIST (ctree)->columns)
return;
-
+
clist = GTK_CLIST (ctree);
-
+
if (pixmap)
{
gdk_pixmap_ref (pixmap);
if (mask)
gdk_pixmap_ref (mask);
}
-
- GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+
+ GTK_CLIST_GET_CLASS (clist)->set_cell_contents
(clist, &(GTK_CTREE_ROW (node)->row), column, GTK_CELL_PIXTEXT,
text, spacing, pixmap, mask);
-
+
tree_draw_node (ctree, node);
}
{
gboolean old_leaf;
gboolean old_expanded;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
-
+
old_leaf = GTK_CTREE_ROW (node)->is_leaf;
old_expanded = GTK_CTREE_ROW (node)->expanded;
-
+
if (is_leaf && GTK_CTREE_ROW (node)->children)
{
GtkCTreeNode *work;
gtk_ctree_remove_node (ctree, ptr);
}
}
-
+
set_node_info (ctree, node, text, spacing, pixmap_closed, mask_closed,
pixmap_opened, mask_opened, is_leaf, expanded);
-
+
if (!is_leaf && !old_leaf)
{
GTK_CTREE_ROW (node)->expanded = old_expanded;
else if (!expanded && old_expanded)
gtk_ctree_collapse (ctree, node);
}
-
+
GTK_CTREE_ROW (node)->expanded = (is_leaf) ? FALSE : expanded;
tree_draw_node (ctree, node);
GtkCList *clist;
GtkRequisition requisition;
gboolean visible = FALSE;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
-
+
if (column < 0 || column >= GTK_CLIST (ctree)->columns)
return;
-
+
clist = GTK_CLIST (ctree);
-
+
if (clist->column[column].auto_resize &&
!GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
{
visible = gtk_ctree_is_viewable (ctree, node);
if (visible)
- GTK_CLIST_CLASS_FW (clist)->cell_size_request
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request
(clist, >K_CTREE_ROW (node)->row, column, &requisition);
}
-
+
GTK_CTREE_ROW (node)->row.cell[column].vertical = vertical;
GTK_CTREE_ROW (node)->row.cell[column].horizontal = horizontal;
-
+
if (visible)
column_auto_resize (clist, >K_CTREE_ROW (node)->row,
column, requisition.width);
-
+
tree_draw_node (ctree, node);
}
gtk_grab_remove (GTK_WIDGET (clist));
gdk_pointer_ungrab (GDK_CURRENT_TIME);
}
-
+
if (clist->htimer)
{
gtk_timeout_remove (clist->htimer);
clist->htimer = 0;
}
-
+
if (clist->vtimer)
{
gtk_timeout_remove (clist->vtimer);
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
-
+
if (selectable == GTK_CTREE_ROW (node)->row.selectable)
return;
-
+
GTK_CTREE_ROW (node)->row.selectable = selectable;
-
+
if (!selectable && GTK_CTREE_ROW (node)->row.state == GTK_STATE_SELECTED)
{
GtkCList *clist;
-
+
clist = GTK_CLIST (ctree);
-
+
if (clist->anchor >= 0 &&
clist->selection_mode == GTK_SELECTION_EXTENDED)
{
clist->drag_button = 0;
remove_grab (clist);
-
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
}
gtk_ctree_unselect (ctree, node);
}
GtkCTreeNode *node)
{
g_return_val_if_fail (node != NULL, FALSE);
-
+
return GTK_CTREE_ROW (node)->row.selectable;
}
g_return_val_if_fail (ctree != NULL, -1);
g_return_val_if_fail (GTK_IS_CTREE (ctree), -1);
g_return_val_if_fail (node != NULL, -1);
-
+
if (column < 0 || column >= GTK_CLIST (ctree)->columns)
return -1;
-
+
return GTK_CTREE_ROW (node)->row.cell[column].type;
}
g_return_val_if_fail (ctree != NULL, 0);
g_return_val_if_fail (GTK_IS_CTREE (ctree), 0);
g_return_val_if_fail (node != NULL, 0);
-
+
if (column < 0 || column >= GTK_CLIST (ctree)->columns)
return 0;
-
+
if (GTK_CTREE_ROW (node)->row.cell[column].type != GTK_CELL_TEXT)
return 0;
-
+
if (text)
*text = GTK_CELL_TEXT (GTK_CTREE_ROW (node)->row.cell[column])->text;
-
+
return 1;
}
g_return_val_if_fail (ctree != NULL, 0);
g_return_val_if_fail (GTK_IS_CTREE (ctree), 0);
g_return_val_if_fail (node != NULL, 0);
-
+
if (column < 0 || column >= GTK_CLIST (ctree)->columns)
return 0;
-
+
if (GTK_CTREE_ROW (node)->row.cell[column].type != GTK_CELL_PIXMAP)
return 0;
-
+
if (pixmap)
*pixmap = GTK_CELL_PIXMAP (GTK_CTREE_ROW(node)->row.cell[column])->pixmap;
if (mask)
*mask = GTK_CELL_PIXMAP (GTK_CTREE_ROW (node)->row.cell[column])->mask;
-
+
return 1;
}
GtkCList *clist;
GtkRequisition requisition;
gboolean visible = FALSE;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
-
+
clist = GTK_CLIST (ctree);
-
+
if (column < 0 || column >= clist->columns)
return;
-
+
if (GTK_CTREE_ROW (node)->row.cell[column].style == style)
return;
-
+
if (clist->column[column].auto_resize &&
!GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
{
visible = gtk_ctree_is_viewable (ctree, node);
if (visible)
- GTK_CLIST_CLASS_FW (clist)->cell_size_request
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request
(clist, >K_CTREE_ROW (node)->row, column, &requisition);
}
-
+
if (GTK_CTREE_ROW (node)->row.cell[column].style)
{
if (GTK_WIDGET_REALIZED (ctree))
gtk_style_detach (GTK_CTREE_ROW (node)->row.cell[column].style);
gtk_style_unref (GTK_CTREE_ROW (node)->row.cell[column].style);
}
-
+
GTK_CTREE_ROW (node)->row.cell[column].style = style;
-
+
if (GTK_CTREE_ROW (node)->row.cell[column].style)
{
gtk_style_ref (GTK_CTREE_ROW (node)->row.cell[column].style);
gtk_style_attach (GTK_CTREE_ROW (node)->row.cell[column].style,
clist->clist_window);
}
-
+
if (visible)
column_auto_resize (clist, >K_CTREE_ROW (node)->row, column,
requisition.width);
-
+
tree_draw_node (ctree, node);
}
g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
g_return_val_if_fail (node != NULL, NULL);
-
+
if (column < 0 || column >= GTK_CLIST (ctree)->columns)
return NULL;
-
+
return GTK_CTREE_ROW (node)->row.cell[column].style;
}
gboolean visible;
gint *old_width = NULL;
gint i;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
-
+
clist = GTK_CLIST (ctree);
-
+
if (GTK_CTREE_ROW (node)->row.style == style)
return;
for (i = 0; i < clist->columns; i++)
if (clist->column[i].auto_resize)
{
- GTK_CLIST_CLASS_FW (clist)->cell_size_request
+ GTK_CLIST_GET_CLASS (clist)->cell_size_request
(clist, >K_CTREE_ROW (node)->row, i, &requisition);
old_width[i] = requisition.width;
}
}
-
+
if (GTK_CTREE_ROW (node)->row.style)
{
if (GTK_WIDGET_REALIZED (ctree))
gtk_style_detach (GTK_CTREE_ROW (node)->row.style);
gtk_style_unref (GTK_CTREE_ROW (node)->row.style);
}
-
+
GTK_CTREE_ROW (node)->row.style = style;
-
+
if (GTK_CTREE_ROW (node)->row.style)
{
gtk_style_ref (GTK_CTREE_ROW (node)->row.style);
gtk_style_attach (GTK_CTREE_ROW (node)->row.style,
clist->clist_window);
}
-
+
if (visible && !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
{
for (i = 0; i < clist->columns; i++)
g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
g_return_val_if_fail (node != NULL, NULL);
-
+
return GTK_CTREE_ROW (node)->row.style;
}
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
-
+
if (color)
{
GTK_CTREE_ROW (node)->row.foreground = *color;
}
else
GTK_CTREE_ROW (node)->row.fg_set = FALSE;
-
+
tree_draw_node (ctree, node);
}
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
-
+
if (color)
{
GTK_CTREE_ROW (node)->row.background = *color;
}
else
GTK_CTREE_ROW (node)->row.bg_set = FALSE;
-
+
tree_draw_node (ctree, node);
}
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
-
+
dnotify = GTK_CTREE_ROW (node)->row.destroy;
ddata = GTK_CTREE_ROW (node)->row.data;
GTK_CTREE_ROW (node)->row.data = data;
GTK_CTREE_ROW (node)->row.destroy = destroy;
-
+
if (dnotify)
dnotify (ddata);
}
{
g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
-
+
return node ? GTK_CTREE_ROW (node)->row.data : NULL;
}
{
gint row = -1;
GtkCList *clist;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
-
+
clist = GTK_CLIST (ctree);
-
+
while (node && !gtk_ctree_is_viewable (ctree, node))
node = GTK_CTREE_ROW (node)->parent;
-
+
if (node)
row = g_list_position (clist->row_list, (GList *)node);
gint indent)
{
GtkCList *clist;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (indent >= 0);
-
+
if (indent == ctree->tree_indent)
return;
-
+
clist = GTK_CLIST (ctree);
ctree->tree_indent = indent;
-
+
if (clist->column[ctree->tree_column].auto_resize &&
!GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
gtk_clist_set_column_width
{
GtkCList *clist;
gint old_spacing;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (spacing >= 0);
-
+
if (spacing == ctree->tree_spacing)
return;
-
+
clist = GTK_CLIST (ctree);
-
+
old_spacing = ctree->tree_spacing;
ctree->tree_spacing = spacing;
-
+
if (clist->column[ctree->tree_column].auto_resize &&
!GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
gtk_clist_set_column_width (clist, ctree->tree_column,
{
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
-
+
show_stub = show_stub != FALSE;
-
+
if (show_stub != ctree->show_stub)
{
GtkCList *clist;
-
+
clist = GTK_CLIST (ctree);
ctree->show_stub = show_stub;
-
+
if (CLIST_UNFROZEN (clist) && clist->rows &&
gtk_clist_row_is_visible (clist, 0) != GTK_VISIBILITY_NONE)
- GTK_CLIST_CLASS_FW (clist)->draw_row
+ GTK_CLIST_GET_CLASS (clist)->draw_row
(clist, NULL, 0, GTK_CLIST_ROW (clist->row_list));
}
}
{
GtkCList *clist;
GtkCTreeLineStyle old_style;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
-
+
if (line_style == ctree->line_style)
return;
-
+
clist = GTK_CLIST (ctree);
-
+
old_style = ctree->line_style;
ctree->line_style = line_style;
-
+
if (clist->column[ctree->tree_column].auto_resize &&
!GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
{
(clist, ctree->tree_column,
clist->column[ctree->tree_column].width + 3);
}
-
+
if (GTK_WIDGET_REALIZED (ctree))
{
switch (line_style)
{
GtkCList *clist;
GtkCTreeExpanderStyle old_style;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
-
+
if (expander_style == ctree->expander_style)
return;
-
+
clist = GTK_CLIST (ctree);
-
+
old_style = ctree->expander_style;
ctree->expander_style = expander_style;
-
+
if (clist->column[ctree->tree_column].auto_resize &&
!GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
{
gint new_width;
-
+
new_width = clist->column[ctree->tree_column].width;
switch (old_style)
{
new_width -= PM_SIZE + 1;
break;
}
-
+
switch (expander_style)
{
case GTK_CTREE_EXPANDER_NONE:
new_width += PM_SIZE + 1;
break;
}
-
+
gtk_clist_set_column_width (clist, ctree->tree_column, new_width);
}
-
+
if (GTK_WIDGET_DRAWABLE (clist))
CLIST_REFRESH (clist);
}
GtkCTreeNode *cmp;
GtkCTreeNode *work;
GtkCList *clist;
-
+
clist = GTK_CLIST (ctree);
-
+
if (node)
list_start = GTK_CTREE_ROW (node)->children;
else
list_start = GTK_CTREE_NODE (clist->row_list);
-
+
while (list_start)
{
cmp = list_start;
{
GtkCList *clist;
GtkCTreeNode *focus_node = NULL;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
-
+
clist = GTK_CLIST (ctree);
-
+
gtk_clist_freeze (clist);
-
+
if (clist->selection_mode == GTK_SELECTION_EXTENDED)
{
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
clist->undo_selection = NULL;
clist->undo_unselection = NULL;
}
-
+
if (!node || (node && gtk_ctree_is_viewable (ctree, node)))
focus_node =
GTK_CTREE_NODE (g_list_nth (clist->row_list, clist->focus_row));
-
+
gtk_ctree_post_recursive (ctree, node, GTK_CTREE_FUNC (tree_sort), NULL);
-
+
if (!node)
tree_sort (ctree, NULL, NULL);
-
+
if (focus_node)
{
clist->focus_row = g_list_position (clist->row_list,(GList *)focus_node);
clist->undo_anchor = clist->focus_row;
}
-
+
gtk_clist_thaw (clist);
}
{
GtkCList *clist;
GtkCTreeNode *focus_node = NULL;
-
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
-
+
clist = GTK_CLIST (ctree);
-
+
gtk_clist_freeze (clist);
-
+
if (clist->selection_mode == GTK_SELECTION_EXTENDED)
{
- GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+ GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
clist->undo_selection = NULL;
clist->undo_unselection = NULL;
}
-
+
if (!node || (node && gtk_ctree_is_viewable (ctree, node)))
focus_node = GTK_CTREE_NODE
(g_list_nth (clist->row_list, clist->focus_row));
-
+
tree_sort (ctree, node, NULL);
-
+
if (focus_node)
{
clist->focus_row = g_list_position (clist->row_list,(GList *)focus_node);
clist->undo_anchor = clist->focus_row;
}
-
+
gtk_clist_thaw (clist);
}
{
GList *list;
GList *focus_node = NULL;
-
+
if (row >= 0 && (focus_node = g_list_nth (clist->row_list, row)))
{
if (GTK_CTREE_ROW (focus_node)->row.state == GTK_STATE_NORMAL &&
if (CLIST_UNFROZEN (clist) &&
gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
- GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row,
- GTK_CLIST_ROW (focus_node));
+ GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row,
+ GTK_CLIST_ROW (focus_node));
}
}
-
+
clist->undo_selection = clist->selection;
clist->selection = NULL;
clist->selection_end = NULL;
{
if (list->data == focus_node)
continue;
-
+
GTK_CTREE_ROW ((GList *)(list->data))->row.state = GTK_STATE_NORMAL;
tree_draw_node (GTK_CTREE (clist), GTK_CTREE_NODE (list->data));
}
gint e;
gint row;
gboolean unselect;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
-
+
if (clist->selection_mode != GTK_SELECTION_EXTENDED)
return;
-
+
if (clist->anchor < 0 || clist->drag_pos < 0)
return;
-
+
ctree = GTK_CTREE (clist);
clist->freeze_count++;
-
+
i = MIN (clist->anchor, clist->drag_pos);
e = MAX (clist->anchor, clist->drag_pos);
-
+
if (clist->undo_selection)
{
list = clist->selection;
clist->selection_end = g_list_last (clist->selection);
clist->undo_selection = list;
list = clist->selection;
-
+
while (list)
{
node = list->data;
list = list->next;
unselect = TRUE;
-
+
if (gtk_ctree_is_viewable (ctree, node))
{
row = g_list_position (clist->row_list, (GList *)node);
}
}
}
-
+
if (clist->anchor < clist->drag_pos)
{
for (node = GTK_CTREE_NODE (g_list_nth (clist->row_list, i)); i <= e;
}
}
}
-
+
clist->undo_unselection = g_list_reverse (clist->undo_unselection);
for (list = clist->undo_unselection; list; list = list->next)
gtk_ctree_select (ctree, list->data);
-
+
clist->anchor = -1;
clist->drag_pos = -1;
-
+
if (!CLIST_UNFROZEN (clist))
clist->freeze_count--;
}
{
GtkCTree *ctree;
GList *work;
-
+
g_return_if_fail (clist != NULL);
g_return_if_fail (GTK_IS_CTREE (clist));
-
+
if (clist->selection_mode != GTK_SELECTION_EXTENDED)
return;
-
+
if (!(clist->undo_selection || clist->undo_unselection))
{
gtk_clist_unselect_all (clist);
return;
}
-
+
ctree = GTK_CTREE (clist);
-
+
for (work = clist->undo_selection; work; work = work->next)
if (GTK_CTREE_ROW (work->data)->row.selectable)
gtk_ctree_select (ctree, GTK_CTREE_NODE (work->data));
-
+
for (work = clist->undo_unselection; work; work = work->next)
if (GTK_CTREE_ROW (work->data)->row.selectable)
gtk_ctree_unselect (ctree, GTK_CTREE_NODE (work->data));
-
+
if (GTK_WIDGET_HAS_FOCUS (clist) && clist->focus_row != clist->undo_anchor)
{
gtk_widget_draw_focus (GTK_WIDGET (clist));
clist->focus_row = clist->undo_anchor;
clist->undo_anchor = -1;
-
+
g_list_free (clist->undo_selection);
g_list_free (clist->undo_unselection);
clist->undo_selection = NULL;
clist->undo_unselection = NULL;
-
+
if (ROW_TOP_YPIXEL (clist, clist->focus_row) + clist->row_height >
clist->clist_window_height)
gtk_clist_moveto (clist, clist->focus_row, -1, 1, 0);
else if (ROW_TOP_YPIXEL (clist, clist->focus_row) < 0)
gtk_clist_moveto (clist, clist->focus_row, -1, 0, 0);
-
+
}
void
{
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
-
+
ctree->drag_compare = cmp_func;
}
{
g_return_val_if_fail (ctree != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
-
+
if (drag_source && drag_source != drag_target &&
(!GTK_CTREE_ROW (drag_source)->children ||
!gtk_ctree_is_ancestor (ctree, drag_source, drag_target)))
drag_dest_info_destroy (gpointer data)
{
GtkCListDestInfo *info = data;
-
+
g_free (info);
}
GtkCListDestInfo *dest_info)
{
GtkWidget *widget;
-
+
widget = GTK_WIDGET (clist);
-
+
dest_info->insert_pos = GTK_CLIST_DRAG_NONE;
-
+
y -= (GTK_CONTAINER (widget)->border_width +
widget->style->klass->ythickness + clist->column_title_area.height);
dest_info->cell.row = ROW_FROM_YPIXEL (clist, y);
-
+
if (dest_info->cell.row >= clist->rows)
{
dest_info->cell.row = clist->rows - 1;
}
if (dest_info->cell.row < -1)
dest_info->cell.row = -1;
-
+
x -= GTK_CONTAINER (widget)->border_width + widget->style->klass->xthickness;
dest_info->cell.column = COLUMN_FROM_XPIXEL (clist, x);
-
+
if (dest_info->cell.row >= 0)
{
gint y_delta;
gint h = 0;
-
+
y_delta = y - ROW_TOP_YPIXEL (clist, dest_info->cell.row);
if (GTK_CLIST_DRAW_DRAG_RECT(clist) &&
dest_info->insert_pos = GTK_CLIST_DRAG_BEFORE;
h = clist->row_height / 2;
}
-
+
if (GTK_CLIST_DRAW_DRAG_LINE(clist))
{
if (y_delta < h)
GtkCList *clist;
GtkCTree *ctree;
gboolean use_icons;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CTREE (widget));
g_return_if_fail (context != NULL);
-
+
clist = GTK_CLIST (widget);
ctree = GTK_CTREE (widget);
-
+
use_icons = GTK_CLIST_USE_DRAG_ICONS (clist);
GTK_CLIST_UNSET_FLAG (clist, CLIST_USE_DRAG_ICONS);
GTK_WIDGET_CLASS (parent_class)->drag_begin (widget, context);
-
+
if (use_icons)
{
GtkCTreeNode *node;
-
+
GTK_CLIST_SET_FLAG (clist, CLIST_USE_DRAG_ICONS);
node = GTK_CTREE_NODE (g_list_nth (clist->row_list,
clist->click_cell.row));
GtkCTree *ctree;
GtkCListDestInfo new_info;
GtkCListDestInfo *dest_info;
-
+
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CTREE (widget), FALSE);
-
+
clist = GTK_CLIST (widget);
ctree = GTK_CTREE (widget);
-
+
dest_info = g_dataset_get_data (context, "gtk-clist-drag-dest");
-
+
if (!dest_info)
{
dest_info = g_new (GtkCListDestInfo, 1);
-
+
dest_info->cell.row = -1;
dest_info->cell.column = -1;
dest_info->insert_pos = GTK_CLIST_DRAG_NONE;
-
+
g_dataset_set_data_full (context, "gtk-clist-drag-dest", dest_info,
drag_dest_info_destroy);
}
-
+
drag_dest_cell (clist, x, y, &new_info);
-
+
if (GTK_CLIST_REORDERABLE (clist))
{
GList *list;
GdkAtom atom = gdk_atom_intern ("gtk-clist-drag-reorder", FALSE);
-
+
list = context->targets;
while (list)
{
break;
list = list->next;
}
-
+
if (list)
{
GtkCTreeNode *drag_source;
GtkCTreeNode *drag_target;
-
+
drag_source = GTK_CTREE_NODE (g_list_nth (clist->row_list,
clist->click_cell.row));
drag_target = GTK_CTREE_NODE (g_list_nth (clist->row_list,
new_info.cell.row));
-
+
if (gtk_drag_get_source_widget (context) != widget ||
!check_drag (ctree, drag_source, drag_target,
new_info.insert_pos))
}
return TRUE;
}
-
+
if (new_info.cell.row != dest_info->cell.row ||
(new_info.cell.row == dest_info->cell.row &&
dest_info->insert_pos != new_info.insert_pos))
{
if (dest_info->cell.row >= 0)
- GTK_CLIST_CLASS_FW (clist)->draw_drag_highlight
+ GTK_CLIST_GET_CLASS (clist)->draw_drag_highlight
(clist,
g_list_nth (clist->row_list, dest_info->cell.row)->data,
dest_info->cell.row, dest_info->insert_pos);
-
+
dest_info->insert_pos = new_info.insert_pos;
dest_info->cell.row = new_info.cell.row;
dest_info->cell.column = new_info.cell.column;
-
- GTK_CLIST_CLASS_FW (clist)->draw_drag_highlight
+
+ GTK_CLIST_GET_CLASS (clist)->draw_drag_highlight
(clist,
g_list_nth (clist->row_list, dest_info->cell.row)->data,
dest_info->cell.row, dest_info->insert_pos);
-
+
gdk_drag_status (context, context->suggested_action, time);
}
return TRUE;
}
}
-
+
dest_info->insert_pos = new_info.insert_pos;
dest_info->cell.row = new_info.cell.row;
dest_info->cell.column = new_info.cell.column;
{
GtkCTree *ctree;
GtkCList *clist;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_CTREE (widget));
g_return_if_fail (context != NULL);
g_return_if_fail (selection_data != NULL);
-
+
ctree = GTK_CTREE (widget);
clist = GTK_CLIST (widget);
-
+
if (GTK_CLIST_REORDERABLE (clist) &&
gtk_drag_get_source_widget (context) == widget &&
selection_data->target ==
selection_data->length == sizeof (GtkCListCellInfo))
{
GtkCListCellInfo *source_info;
-
+
source_info = (GtkCListCellInfo *)(selection_data->data);
if (source_info)
{
GtkCListDestInfo dest_info;
GtkCTreeNode *source_node;
GtkCTreeNode *dest_node;
-
+
drag_dest_cell (clist, x, y, &dest_info);
source_node = GTK_CTREE_NODE (g_list_nth (clist->row_list,
source_info->row));
dest_node = GTK_CTREE_NODE (g_list_nth (clist->row_list,
dest_info.cell.row));
-
+
if (!source_node || !dest_node)
return;
-
+
switch (dest_info.insert_pos)
{
case GTK_CLIST_DRAG_NONE:
static void gtk_curve_get_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
-static void gtk_curve_finalize (GtkObject *object);
+static void gtk_curve_finalize (GObject *object);
static gint gtk_curve_graph_events (GtkWidget *widget,
GdkEvent *event,
GtkCurve *c);
static void
gtk_curve_class_init (GtkCurveClass *class)
{
- GtkObjectClass *object_class;
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+ GtkObjectClass *object_class = GTK_OBJECT_CLASS (class);
parent_class = gtk_type_class (GTK_TYPE_DRAWING_AREA);
- object_class = (GtkObjectClass *) class;
-
+ gobject_class->finalize = gtk_curve_finalize;
+
object_class->set_arg = gtk_curve_set_arg;
object_class->get_arg = gtk_curve_get_arg;
- object_class->finalize = gtk_curve_finalize;
curve_type_changed_signal =
- gtk_signal_new ("curve_type_changed", GTK_RUN_FIRST, object_class->type,
+ gtk_signal_new ("curve_type_changed", GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCurveClass, curve_type_changed),
gtk_marshal_NONE__NONE, GTK_TYPE_NONE, 0);
gtk_object_class_add_signals (object_class, &curve_type_changed_signal, 1);
}
static void
-gtk_curve_finalize (GtkObject *object)
+gtk_curve_finalize (GObject *object)
{
GtkCurve *curve;
if (curve->ctlpoint)
g_free (curve->ctlpoint);
- (*GTK_OBJECT_CLASS (parent_class)->finalize) (object);
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
data_signals[DISCONNECT] =
gtk_signal_new ("disconnect",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkDataClass, disconnect),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
editable_signals[CHANGED] =
gtk_signal_new ("changed",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkEditableClass, changed),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
editable_signals[INSERT_TEXT] =
gtk_signal_new ("insert_text",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkEditableClass, insert_text),
gtk_marshal_NONE__POINTER_INT_POINTER,
GTK_TYPE_NONE,
editable_signals[DELETE_TEXT] =
gtk_signal_new ("delete_text",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkEditableClass, delete_text),
gtk_marshal_NONE__INT_INT,
GTK_TYPE_NONE,
editable_signals[ACTIVATE] =
gtk_signal_new ("activate",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkEditableClass, activate),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
editable_signals[SET_EDITABLE] =
gtk_signal_new ("set-editable",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkEditableClass, set_editable),
gtk_marshal_NONE__BOOL,
GTK_TYPE_NONE, 1,
editable_signals[MOVE_CURSOR] =
gtk_signal_new ("move_cursor",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkEditableClass, move_cursor),
gtk_marshal_NONE__INT_INT,
GTK_TYPE_NONE, 2,
editable_signals[MOVE_WORD] =
gtk_signal_new ("move_word",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkEditableClass, move_word),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
editable_signals[MOVE_PAGE] =
gtk_signal_new ("move_page",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkEditableClass, move_page),
gtk_marshal_NONE__INT_INT,
GTK_TYPE_NONE, 2,
editable_signals[MOVE_TO_ROW] =
gtk_signal_new ("move_to_row",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkEditableClass, move_to_row),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
editable_signals[MOVE_TO_COLUMN] =
gtk_signal_new ("move_to_column",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkEditableClass, move_to_column),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
editable_signals[KILL_CHAR] =
gtk_signal_new ("kill_char",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkEditableClass, kill_char),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
editable_signals[KILL_WORD] =
gtk_signal_new ("kill_word",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkEditableClass, kill_word),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
editable_signals[KILL_LINE] =
gtk_signal_new ("kill_line",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkEditableClass, kill_line),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
editable_signals[CUT_CLIPBOARD] =
gtk_signal_new ("cut_clipboard",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkEditableClass, cut_clipboard),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
editable_signals[COPY_CLIPBOARD] =
gtk_signal_new ("copy_clipboard",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkEditableClass, copy_clipboard),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
editable_signals[PASTE_CLIPBOARD] =
gtk_signal_new ("paste_clipboard",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkEditableClass, paste_clipboard),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
gtk_widget_ref (GTK_WIDGET (editable));
- klass = GTK_EDITABLE_CLASS (GTK_OBJECT (editable)->klass);
+ klass = GTK_EDITABLE_GET_CLASS (editable);
if (new_text_length <= 64)
text = buf;
gtk_widget_ref (GTK_WIDGET (editable));
- klass = GTK_EDITABLE_CLASS (GTK_OBJECT (editable)->klass);
+ klass = GTK_EDITABLE_GET_CLASS (editable);
gtk_signal_emit (GTK_OBJECT (editable), editable_signals[DELETE_TEXT], start_pos, end_pos);
gtk_signal_emit (GTK_OBJECT (editable), editable_signals[CHANGED]);
g_return_if_fail (editable != NULL);
g_return_if_fail (GTK_IS_EDITABLE (editable));
- klass = GTK_EDITABLE_CLASS (GTK_OBJECT (editable)->klass);
+ klass = GTK_EDITABLE_GET_CLASS (editable);
klass->update_text (editable, start_pos, end_pos);
}
g_return_val_if_fail (editable != NULL, NULL);
g_return_val_if_fail (GTK_IS_EDITABLE (editable), NULL);
- klass = GTK_EDITABLE_CLASS (GTK_OBJECT (editable)->klass);
+ klass = GTK_EDITABLE_GET_CLASS (editable);
return klass->get_chars (editable, start, end);
}
g_return_if_fail (editable != NULL);
g_return_if_fail (GTK_IS_EDITABLE (editable));
- klass = GTK_EDITABLE_CLASS (GTK_OBJECT (editable)->klass);
+ klass = GTK_EDITABLE_GET_CLASS (editable);
klass->set_selection (editable, start_pos, end_pos);
}
g_return_if_fail (editable != NULL);
g_return_if_fail (GTK_IS_EDITABLE (editable));
- klass = GTK_EDITABLE_CLASS (GTK_OBJECT (editable)->klass);
+ klass = GTK_EDITABLE_GET_CLASS (editable);
klass->set_position (editable, position);
}
static void gtk_entry_get_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
-static void gtk_entry_finalize (GtkObject *object);
+static void gtk_entry_finalize (GObject *object);
static void gtk_entry_realize (GtkWidget *widget);
static void gtk_entry_unrealize (GtkWidget *widget);
static void gtk_entry_draw_focus (GtkWidget *widget);
static void
gtk_entry_class_init (GtkEntryClass *class)
{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkEditableClass *editable_class;
editable_class = (GtkEditableClass*) class;
parent_class = gtk_type_class (GTK_TYPE_EDITABLE);
+ gobject_class->finalize = gtk_entry_finalize;
+
gtk_object_add_arg_type ("GtkEntry::max_length", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_MAX_LENGTH);
gtk_object_add_arg_type ("GtkEntry::visibility", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_VISIBILITY);
object_class->set_arg = gtk_entry_set_arg;
object_class->get_arg = gtk_entry_get_arg;
- object_class->finalize = gtk_entry_finalize;
widget_class->realize = gtk_entry_realize;
widget_class->unrealize = gtk_entry_unrealize;
}
static void
-gtk_entry_finalize (GtkObject *object)
+gtk_entry_finalize (GObject *object)
{
GtkEntry *entry;
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_ENTRY (object));
entry = GTK_ENTRY (object);
if (entry->backing_pixmap)
gdk_pixmap_unref (entry->backing_pixmap);
- (* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
if (filesel->fileop_ren_file)
- {
- gtk_widget_destroy (filesel->fileop_ren_file);
- filesel->fileop_ren_file = NULL;
- }
+ gtk_widget_destroy (filesel->fileop_ren_file);
if (filesel->fileop_del_file)
{
GtkFileSelection *filesel;
GList *list;
HistoryCallbackArg *callback_arg;
-
- g_return_if_fail (object != NULL);
+
g_return_if_fail (GTK_IS_FILE_SELECTION (object));
-
+
filesel = GTK_FILE_SELECTION (object);
if (filesel->fileop_dialog)
- gtk_widget_destroy (filesel->fileop_dialog);
+ {
+ gtk_widget_destroy (filesel->fileop_dialog);
+ filesel->fileop_dialog = NULL;
+ }
if (filesel->history_list)
{
g_list_free (filesel->history_list);
filesel->history_list = NULL;
}
-
- cmpl_free_state (filesel->cmpl_state);
- filesel->cmpl_state = NULL;
- if (GTK_OBJECT_CLASS (parent_class)->destroy)
- (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+ if (filesel->cmpl_state)
+ {
+ cmpl_free_state (filesel->cmpl_state);
+ filesel->cmpl_state = NULL;
+ }
+
+ GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
/* Begin file operations callbacks */
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
if (fs->fileop_dialog)
- return;
+ return;
/* main dialog */
- fs->fileop_dialog = dialog = gtk_dialog_new ();
+ dialog = gtk_dialog_new ();
+ fs->fileop_dialog = dialog;
gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
(GtkSignalFunc) gtk_file_selection_fileop_destroy,
(gpointer) fs);
static void
cmpl_free_state (CompletionState* cmpl_state)
{
+ g_return_if_fail (cmpl_state != NULL);
+
cmpl_free_dir_list (cmpl_state->directory_storage);
cmpl_free_dir_sent_list (cmpl_state->directory_sent_storage);
static void gtk_frame_get_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
-static void gtk_frame_finalize (GtkObject *object);
+static void gtk_frame_finalize (GObject *object);
static void gtk_frame_paint (GtkWidget *widget,
GdkRectangle *area);
static void gtk_frame_draw (GtkWidget *widget,
static void
gtk_frame_class_init (GtkFrameClass *class)
{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
parent_class = gtk_type_class (gtk_bin_get_type ());
+ gobject_class->finalize = gtk_frame_finalize;
+
gtk_object_add_arg_type ("GtkFrame::label", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_LABEL);
gtk_object_add_arg_type ("GtkFrame::label_xalign", GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_LABEL_XALIGN);
gtk_object_add_arg_type ("GtkFrame::label_yalign", GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_LABEL_YALIGN);
object_class->set_arg = gtk_frame_set_arg;
object_class->get_arg = gtk_frame_get_arg;
- object_class->finalize = gtk_frame_finalize;
widget_class->draw = gtk_frame_draw;
widget_class->expose_event = gtk_frame_expose;
static void
-gtk_frame_finalize (GtkObject *object)
+gtk_frame_finalize (GObject *object)
{
GtkFrame *frame;
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_FRAME (object));
frame = GTK_FRAME (object);
if (frame->label)
g_free (frame->label);
- (* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
handle_box_signals[SIGNAL_CHILD_ATTACHED] =
gtk_signal_new ("child_attached",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkHandleBoxClass, child_attached),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1,
handle_box_signals[SIGNAL_CHILD_DETACHED] =
gtk_signal_new ("child_detached",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkHandleBoxClass, child_detached),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1,
#include "gdk/gdkkeysyms.h"
-#define SCALE_CLASS(w) GTK_SCALE_CLASS (GTK_OBJECT (w)->klass)
-#define RANGE_CLASS(w) GTK_RANGE_CLASS (GTK_OBJECT (w)->klass)
+#define SCALE_CLASS(w) GTK_SCALE_GET_CLASS (w)
+#define RANGE_CLASS(w) GTK_RANGE_GET_CLASS (w)
enum {
ARG_0,
gtk_object_add_arg_type ("GtkHScale::adjustment",
GTK_TYPE_ADJUSTMENT,
- GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+ GTK_ARG_READWRITE,
ARG_ADJUSTMENT);
object_class->set_arg = gtk_hscale_set_arg;
#define EPSILON 0.01
-#define RANGE_CLASS(w) GTK_RANGE_CLASS (GTK_OBJECT (w)->klass)
+#define RANGE_CLASS(w) GTK_RANGE_GET_CLASS (w)
enum {
ARG_0,
gtk_object_add_arg_type ("GtkHScrollbar::adjustment",
GTK_TYPE_ADJUSTMENT,
- GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+ GTK_ARG_READWRITE,
ARG_ADJUSTMENT);
object_class->set_arg = gtk_hscrollbar_set_arg;
#include "gtksignal.h"
#include "gtkhsv.h"
-\f
+/*
+ * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
+ * file for a list of people on the GTK+ Team. See the ChangeLog
+ * files for a list of changes. These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
/* Default width/height */
#define DEFAULT_SIZE 100
/* Default ring width */
#define DEFAULT_RING_WIDTH 10
-\f
/* Dragging modes */
typedef enum {
- DRAG_NONE,
- DRAG_H,
- DRAG_SV
+ DRAG_NONE,
+ DRAG_H,
+ DRAG_SV
} DragMode;
/* Private part of the GtkHSV structure */
typedef struct {
- /* Color value */
- double h;
- double s;
- double v;
-
- /* Size and ring width */
- int size;
- int ring_width;
-
- /* Window for capturing events */
- GdkWindow *window;
-
- /* GC for drawing */
- GdkGC *gc;
-
- /* Dragging mode */
- DragMode mode;
+ /* Color value */
+ double h;
+ double s;
+ double v;
+
+ /* Size and ring width */
+ int size;
+ int ring_width;
+
+ /* Window for capturing events */
+ GdkWindow *window;
+
+ /* GC for drawing */
+ GdkGC *gc;
+
+ /* Dragging mode */
+ DragMode mode;
} HSVPrivate;
\f
/* Signal IDs */
enum {
- CHANGED,
- LAST_SIGNAL
+ CHANGED,
+ LAST_SIGNAL
};
-static void gtk_hsv_class_init (GtkHSVClass *class);
-static void gtk_hsv_init (GtkHSV *hsv);
-static void gtk_hsv_destroy (GtkObject *object);
-
-static void gtk_hsv_map (GtkWidget *widget);
-static void gtk_hsv_unmap (GtkWidget *widget);
-static void gtk_hsv_realize (GtkWidget *widget);
-static void gtk_hsv_unrealize (GtkWidget *widget);
-static void gtk_hsv_size_request (GtkWidget *widget, GtkRequisition *requisition);
-static void gtk_hsv_size_allocate (GtkWidget *widget, GtkAllocation *allocation);
-static gint gtk_hsv_button_press (GtkWidget *widget, GdkEventButton *event);
-static gint gtk_hsv_button_release (GtkWidget *widget, GdkEventButton *event);
-static gint gtk_hsv_motion (GtkWidget *widget, GdkEventMotion *event);
-static gint gtk_hsv_expose (GtkWidget *widget, GdkEventExpose *event);
+static void gtk_hsv_class_init (GtkHSVClass *class);
+static void gtk_hsv_init (GtkHSV *hsv);
+static void gtk_hsv_destroy (GtkObject *object);
+static void gtk_hsv_map (GtkWidget *widget);
+static void gtk_hsv_unmap (GtkWidget *widget);
+static void gtk_hsv_realize (GtkWidget *widget);
+static void gtk_hsv_unrealize (GtkWidget *widget);
+static void gtk_hsv_size_request (GtkWidget *widget,
+ GtkRequisition *requisition);
+static void gtk_hsv_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation);
+static gint gtk_hsv_button_press (GtkWidget *widget,
+ GdkEventButton *event);
+static gint gtk_hsv_button_release (GtkWidget *widget,
+ GdkEventButton *event);
+static gint gtk_hsv_motion (GtkWidget *widget,
+ GdkEventMotion *event);
+static gint gtk_hsv_expose (GtkWidget *widget,
+ GdkEventExpose *event);
static guint hsv_signals[LAST_SIGNAL];
-
static GtkWidgetClass *parent_class;
-\f
/**
* gtk_hsv_get_type:
GtkType
gtk_hsv_get_type (void)
{
- static GtkType hsv_type = 0;
-
- if (!hsv_type) {
- static const GtkTypeInfo hsv_info = {
- "GtkHSV",
- sizeof (GtkHSV),
- sizeof (GtkHSVClass),
- (GtkClassInitFunc) gtk_hsv_class_init,
- (GtkObjectInitFunc) gtk_hsv_init,
- NULL, /* reserved_1 */
- NULL, /* reserved_2 */
- (GtkClassInitFunc) NULL
- };
-
- hsv_type = gtk_type_unique (gtk_widget_get_type (), &hsv_info);
- }
-
- return hsv_type;
+ static GtkType hsv_type = 0;
+
+ if (!hsv_type) {
+ static const GtkTypeInfo hsv_info = {
+ "GtkHSV",
+ sizeof (GtkHSV),
+ sizeof (GtkHSVClass),
+ (GtkClassInitFunc) gtk_hsv_class_init,
+ (GtkObjectInitFunc) gtk_hsv_init,
+ NULL, /* reserved_1 */
+ NULL, /* reserved_2 */
+ (GtkClassInitFunc) NULL
+ };
+
+ hsv_type = gtk_type_unique (GTK_TYPE_WIDGET, &hsv_info);
+ }
+
+ return hsv_type;
}
/* Class initialization function for the HSV color selector */
static void
gtk_hsv_class_init (GtkHSVClass *class)
{
- GtkObjectClass *object_class;
- GtkWidgetClass *widget_class;
-
- object_class = (GtkObjectClass *) class;
- widget_class = (GtkWidgetClass *) class;
-
- parent_class = gtk_type_class (gtk_widget_get_type ());
-
- hsv_signals[CHANGED] =
- gtk_signal_new ("changed",
- GTK_RUN_FIRST,
- object_class->type,
- GTK_SIGNAL_OFFSET (GtkHSVClass, changed),
- gtk_marshal_NONE__NONE,
- GTK_TYPE_NONE, 0);
-
- gtk_object_class_add_signals (object_class, hsv_signals, LAST_SIGNAL);
-
- object_class->destroy = gtk_hsv_destroy;
-
- widget_class->map = gtk_hsv_map;
- widget_class->unmap = gtk_hsv_unmap;
- widget_class->realize = gtk_hsv_realize;
- widget_class->unrealize = gtk_hsv_unrealize;
- widget_class->size_request = gtk_hsv_size_request;
- widget_class->size_allocate = gtk_hsv_size_allocate;
- widget_class->button_press_event = gtk_hsv_button_press;
- widget_class->button_release_event = gtk_hsv_button_release;
- widget_class->motion_notify_event = gtk_hsv_motion;
- widget_class->expose_event = gtk_hsv_expose;
+ GtkObjectClass *object_class;
+ GtkWidgetClass *widget_class;
+
+ object_class = (GtkObjectClass *) class;
+ widget_class = (GtkWidgetClass *) class;
+
+ parent_class = gtk_type_class (GTK_TYPE_WIDGET);
+
+ hsv_signals[CHANGED] =
+ gtk_signal_new ("changed",
+ GTK_RUN_FIRST,
+ GTK_CLASS_TYPE (object_class),
+ GTK_SIGNAL_OFFSET (GtkHSVClass, changed),
+ gtk_marshal_NONE__NONE,
+ GTK_TYPE_NONE, 0);
+ gtk_object_class_add_signals (object_class, hsv_signals, LAST_SIGNAL);
+
+ object_class->destroy = gtk_hsv_destroy;
+
+ widget_class->map = gtk_hsv_map;
+ widget_class->unmap = gtk_hsv_unmap;
+ widget_class->realize = gtk_hsv_realize;
+ widget_class->unrealize = gtk_hsv_unrealize;
+ widget_class->size_request = gtk_hsv_size_request;
+ widget_class->size_allocate = gtk_hsv_size_allocate;
+ widget_class->button_press_event = gtk_hsv_button_press;
+ widget_class->button_release_event = gtk_hsv_button_release;
+ widget_class->motion_notify_event = gtk_hsv_motion;
+ widget_class->expose_event = gtk_hsv_expose;
}
/* Object initialization function for the HSV color selector */
static void
gtk_hsv_init (GtkHSV *hsv)
{
- HSVPrivate *priv;
-
- priv = g_new0 (HSVPrivate, 1);
- hsv->priv = priv;
-
- GTK_WIDGET_SET_FLAGS (hsv, GTK_NO_WINDOW);
-
- priv->h = 0.0;
- priv->s = 0.0;
- priv->v = 0.0;
-
- priv->size = DEFAULT_SIZE;
- priv->ring_width = DEFAULT_RING_WIDTH;
+ HSVPrivate *priv;
+
+ priv = g_new0 (HSVPrivate, 1);
+ hsv->priv = priv;
+
+ GTK_WIDGET_SET_FLAGS (hsv, GTK_NO_WINDOW);
+
+ priv->h = 0.0;
+ priv->s = 0.0;
+ priv->v = 0.0;
+
+ priv->size = DEFAULT_SIZE;
+ priv->ring_width = DEFAULT_RING_WIDTH;
}
/* Destroy handler for the HSV color selector */
static void
gtk_hsv_destroy (GtkObject *object)
{
- GtkHSV *hsv;
- HSVPrivate *priv;
-
- g_return_if_fail (object != NULL);
- g_return_if_fail (GTK_IS_HSV (object));
-
- hsv = GTK_HSV (object);
- priv = hsv->priv;
-
- g_free (priv);
-
- if (GTK_OBJECT_CLASS (parent_class)->destroy)
- (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+ GtkHSV *hsv;
+
+ g_return_if_fail (GTK_IS_HSV (object));
+
+ hsv = GTK_HSV (object);
+
+ if (hsv->priv)
+ {
+ g_free (hsv->priv);
+ hsv->priv = NULL;
+ }
+
+ GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
-\f
-
/* Default signal handlers */
/* Map handler for the HSV color selector */
static void
gtk_hsv_map (GtkWidget *widget)
{
- GtkHSV *hsv;
- HSVPrivate *priv;
-
- hsv = GTK_HSV (widget);
- priv = hsv->priv;
-
- if (GTK_WIDGET_MAPPED (widget))
- return;
-
- GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
-
- gdk_window_show (priv->window);
+ GtkHSV *hsv;
+ HSVPrivate *priv;
+
+ hsv = GTK_HSV (widget);
+ priv = hsv->priv;
+
+ if (GTK_WIDGET_MAPPED (widget))
+ return;
+
+ GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
+
+ gdk_window_show (priv->window);
}
/* Unmap handler for the HSV color selector */
static void
gtk_hsv_unmap (GtkWidget *widget)
{
- GtkHSV *hsv;
- HSVPrivate *priv;
-
- hsv = GTK_HSV (widget);
- priv = hsv->priv;
-
- if (!GTK_WIDGET_MAPPED (widget))
- return;
-
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
-
- gdk_window_hide (priv->window);
+ GtkHSV *hsv;
+ HSVPrivate *priv;
+
+ hsv = GTK_HSV (widget);
+ priv = hsv->priv;
+
+ if (!GTK_WIDGET_MAPPED (widget))
+ return;
+
+ GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
+
+ gdk_window_hide (priv->window);
}
/* Realize handler for the HSV color selector */
static void
gtk_hsv_realize (GtkWidget *widget)
{
- GtkHSV *hsv;
- HSVPrivate *priv;
- GdkWindowAttr attr;
- int attr_mask;
- GdkWindow *parent_window;
-
- hsv = GTK_HSV (widget);
- priv = hsv->priv;
-
- GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
-
- /* Create window */
-
- attr.window_type = GDK_WINDOW_CHILD;
- attr.x = widget->allocation.x;
- attr.y = widget->allocation.y;
- attr.width = widget->allocation.width;
- attr.height = widget->allocation.height;
- attr.wclass = GDK_INPUT_ONLY;
- attr.event_mask = gtk_widget_get_events (widget);
- attr.event_mask |= (GDK_BUTTON_PRESS_MASK
- | GDK_BUTTON_RELEASE_MASK
- | GDK_POINTER_MOTION_MASK);
-
- attr_mask = GDK_WA_X | GDK_WA_Y;
-
- parent_window = gtk_widget_get_parent_window (widget);
-
- widget->window = parent_window;
- gdk_window_ref (widget->window);
-
- priv->window = gdk_window_new (parent_window, &attr, attr_mask);
- gdk_window_set_user_data (priv->window, hsv);
-
- widget->style = gtk_style_attach (widget->style, widget->window);
-
- /* Create GC */
-
- priv->gc = gdk_gc_new (parent_window);
+ GtkHSV *hsv;
+ HSVPrivate *priv;
+ GdkWindowAttr attr;
+ int attr_mask;
+ GdkWindow *parent_window;
+
+ hsv = GTK_HSV (widget);
+ priv = hsv->priv;
+
+ GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
+
+ /* Create window */
+
+ attr.window_type = GDK_WINDOW_CHILD;
+ attr.x = widget->allocation.x;
+ attr.y = widget->allocation.y;
+ attr.width = widget->allocation.width;
+ attr.height = widget->allocation.height;
+ attr.wclass = GDK_INPUT_ONLY;
+ attr.event_mask = gtk_widget_get_events (widget);
+ attr.event_mask |= (GDK_BUTTON_PRESS_MASK
+ | GDK_BUTTON_RELEASE_MASK
+ | GDK_POINTER_MOTION_MASK);
+
+ attr_mask = GDK_WA_X | GDK_WA_Y;
+
+ parent_window = gtk_widget_get_parent_window (widget);
+
+ widget->window = parent_window;
+ gdk_window_ref (widget->window);
+
+ priv->window = gdk_window_new (parent_window, &attr, attr_mask);
+ gdk_window_set_user_data (priv->window, hsv);
+
+ widget->style = gtk_style_attach (widget->style, widget->window);
+
+ /* Create GC */
+
+ priv->gc = gdk_gc_new (parent_window);
}
/* Unrealize handler for the HSV color selector */
static void
gtk_hsv_unrealize (GtkWidget *widget)
{
- GtkHSV *hsv;
- HSVPrivate *priv;
-
- hsv = GTK_HSV (widget);
- priv = hsv->priv;
-
- gdk_window_set_user_data (priv->window, NULL);
- gdk_window_destroy (priv->window);
- priv->window = NULL;
-
- gdk_gc_unref (priv->gc);
- priv->gc = NULL;
-
- if (GTK_WIDGET_CLASS (parent_class)->unrealize)
- (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
+ GtkHSV *hsv;
+ HSVPrivate *priv;
+
+ hsv = GTK_HSV (widget);
+ priv = hsv->priv;
+
+ gdk_window_set_user_data (priv->window, NULL);
+ gdk_window_destroy (priv->window);
+ priv->window = NULL;
+
+ gdk_gc_unref (priv->gc);
+ priv->gc = NULL;
+
+ if (GTK_WIDGET_CLASS (parent_class)->unrealize)
+ GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
}
/* Size_request handler for the HSV color selector */
static void
-gtk_hsv_size_request (GtkWidget *widget, GtkRequisition *requisition)
+gtk_hsv_size_request (GtkWidget *widget,
+ GtkRequisition *requisition)
{
- GtkHSV *hsv;
- HSVPrivate *priv;
-
- hsv = GTK_HSV (widget);
- priv = hsv->priv;
-
- requisition->width = priv->size;
- requisition->height = priv->size;
+ GtkHSV *hsv;
+ HSVPrivate *priv;
+
+ hsv = GTK_HSV (widget);
+ priv = hsv->priv;
+
+ requisition->width = priv->size;
+ requisition->height = priv->size;
}
/* Size_allocate handler for the HSV color selector */
static void
-gtk_hsv_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
+gtk_hsv_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation)
{
- GtkHSV *hsv;
- HSVPrivate *priv;
-
- hsv = GTK_HSV (widget);
- priv = hsv->priv;
-
- widget->allocation = *allocation;
-
- if (GTK_WIDGET_REALIZED (widget))
- gdk_window_move_resize (priv->window,
- allocation->x,
- allocation->y,
- allocation->width,
- allocation->height);
+ GtkHSV *hsv;
+ HSVPrivate *priv;
+
+ hsv = GTK_HSV (widget);
+ priv = hsv->priv;
+
+ widget->allocation = *allocation;
+
+ if (GTK_WIDGET_REALIZED (widget))
+ gdk_window_move_resize (priv->window,
+ allocation->x,
+ allocation->y,
+ allocation->width,
+ allocation->height);
}
-\f
/* Utility functions */
/* Converts from HSV to RGB */
static void
-hsv_to_rgb (double *h, double *s, double *v)
+hsv_to_rgb (gdouble *h,
+ gdouble *s,
+ gdouble *v)
{
- double hue, saturation, value;
- double f, p, q, t;
-
- if (*s == 0.0) {
- *h = *v;
- *s = *v;
- *v = *v; /* heh */
- } else {
- hue = *h * 6.0;
- saturation = *s;
- value = *v;
-
- if (hue == 6.0)
- hue = 0.0;
-
- f = hue - (int) hue;
- p = value * (1.0 - saturation);
- q = value * (1.0 - saturation * f);
- t = value * (1.0 - saturation * (1.0 - f));
-
- switch ((int) hue) {
- case 0:
- *h = value;
- *s = t;
- *v = p;
- break;
-
- case 1:
- *h = q;
- *s = value;
- *v = p;
- break;
-
- case 2:
- *h = p;
- *s = value;
- *v = t;
- break;
-
- case 3:
- *h = p;
- *s = q;
- *v = value;
- break;
-
- case 4:
- *h = t;
- *s = p;
- *v = value;
- break;
-
- case 5:
- *h = value;
- *s = p;
- *v = q;
- break;
-
- default:
- g_assert_not_reached ();
- }
+ gdouble hue, saturation, value;
+ gdouble f, p, q, t;
+
+ if (*s == 0.0)
+ {
+ *h = *v;
+ *s = *v;
+ *v = *v; /* heh */
+ }
+ else
+ {
+ hue = *h * 6.0;
+ saturation = *s;
+ value = *v;
+
+ if (hue == 6.0)
+ hue = 0.0;
+
+ f = hue - (int) hue;
+ p = value * (1.0 - saturation);
+ q = value * (1.0 - saturation * f);
+ t = value * (1.0 - saturation * (1.0 - f));
+
+ switch ((int) hue)
+ {
+ case 0:
+ *h = value;
+ *s = t;
+ *v = p;
+ break;
+
+ case 1:
+ *h = q;
+ *s = value;
+ *v = p;
+ break;
+
+ case 2:
+ *h = p;
+ *s = value;
+ *v = t;
+ break;
+
+ case 3:
+ *h = p;
+ *s = q;
+ *v = value;
+ break;
+
+ case 4:
+ *h = t;
+ *s = p;
+ *v = value;
+ break;
+
+ case 5:
+ *h = value;
+ *s = p;
+ *v = q;
+ break;
+
+ default:
+ g_assert_not_reached ();
}
+ }
}
/* Converts from RGB to HSV */
static void
-rgb_to_hsv (double *r, double *g, double *b)
+rgb_to_hsv (gdouble *r,
+ gdouble *g,
+ gdouble *b)
{
- double red, green, blue;
- double h, s, v;
- double min, max;
- double delta;
-
- red = *r;
- green = *g;
- blue = *b;
-
- h = 0.0;
-
- if (red > green) {
- if (red > blue)
- max = red;
- else
- max = blue;
-
- if (green < blue)
- min = green;
- else
- min = blue;
- } else {
- if (green > blue)
- max = green;
- else
- max = blue;
-
- if (red < blue)
- min = red;
- else
- min = blue;
- }
-
- v = max;
-
- if (max != 0.0)
- s = (max - min) / max;
- else
- s = 0.0;
-
- if (s == 0.0)
- h = 0.0;
- else {
- delta = max - min;
-
- if (red == max)
- h = (green - blue) / delta;
- else if (green == max)
- h = 2 + (blue - red) / delta;
- else if (blue == max)
- h = 4 + (red - green) / delta;
-
- h /= 6.0;
-
- if (h < 0.0)
- h += 1.0;
- else if (h > 1.0)
- h -= 1.0;
- }
-
- *r = h;
- *g = s;
- *b = v;
+ gdouble red, green, blue;
+ gdouble h, s, v;
+ gdouble min, max;
+ gdouble delta;
+
+ red = *r;
+ green = *g;
+ blue = *b;
+
+ h = 0.0;
+
+ if (red > green)
+ {
+ if (red > blue)
+ max = red;
+ else
+ max = blue;
+
+ if (green < blue)
+ min = green;
+ else
+ min = blue;
+ }
+ else
+ {
+ if (green > blue)
+ max = green;
+ else
+ max = blue;
+
+ if (red < blue)
+ min = red;
+ else
+ min = blue;
+ }
+
+ v = max;
+
+ if (max != 0.0)
+ s = (max - min) / max;
+ else
+ s = 0.0;
+
+ if (s == 0.0)
+ h = 0.0;
+ else
+ {
+ delta = max - min;
+
+ if (red == max)
+ h = (green - blue) / delta;
+ else if (green == max)
+ h = 2 + (blue - red) / delta;
+ else if (blue == max)
+ h = 4 + (red - green) / delta;
+
+ h /= 6.0;
+
+ if (h < 0.0)
+ h += 1.0;
+ else if (h > 1.0)
+ h -= 1.0;
+ }
+
+ *r = h;
+ *g = s;
+ *b = v;
}
/* Computes the vertices of the saturation/value triangle */
static void
-compute_triangle (GtkHSV *hsv, int *hx, int *hy, int *sx, int *sy, int *vx, int *vy)
+compute_triangle (GtkHSV *hsv,
+ gint *hx,
+ gint *hy,
+ gint *sx,
+ gint *sy,
+ gint *vx,
+ gint *vy)
{
- HSVPrivate *priv;
- double center;
- double inner, outer;
- double angle;
-
- priv = hsv->priv;
-
- center = priv->size / 2.0;
- outer = priv->size / 2.0;
- inner = outer - priv->ring_width;
- angle = priv->h * 2.0 * M_PI;
-
- *hx = floor (center + cos (angle) * inner + 0.5);
- *hy = floor (center - sin (angle) * inner + 0.5);
- *sx = floor (center + cos (angle + 2.0 * M_PI / 3.0) * inner + 0.5);
- *sy = floor (center - sin (angle + 2.0 * M_PI / 3.0) * inner + 0.5);
- *vx = floor (center + cos (angle + 4.0 * M_PI / 3.0) * inner + 0.5);
- *vy = floor (center - sin (angle + 4.0 * M_PI / 3.0) * inner + 0.5);
+ HSVPrivate *priv;
+ gdouble center;
+ gdouble inner, outer;
+ gdouble angle;
+
+ priv = hsv->priv;
+
+ center = priv->size / 2.0;
+ outer = priv->size / 2.0;
+ inner = outer - priv->ring_width;
+ angle = priv->h * 2.0 * M_PI;
+
+ *hx = floor (center + cos (angle) * inner + 0.5);
+ *hy = floor (center - sin (angle) * inner + 0.5);
+ *sx = floor (center + cos (angle + 2.0 * M_PI / 3.0) * inner + 0.5);
+ *sy = floor (center - sin (angle + 2.0 * M_PI / 3.0) * inner + 0.5);
+ *vx = floor (center + cos (angle + 4.0 * M_PI / 3.0) * inner + 0.5);
+ *vy = floor (center - sin (angle + 4.0 * M_PI / 3.0) * inner + 0.5);
}
/* Computes whether a point is inside the hue ring */
static gboolean
-is_in_ring (GtkHSV *hsv, double x, double y)
+is_in_ring (GtkHSV *hsv,
+ gdouble x,
+ gdouble y)
{
- HSVPrivate *priv;
- double dx, dy, dist;
- double center, inner, outer;
-
- priv = hsv->priv;
-
- center = priv->size / 2.0;
- outer = priv->size / 2.0;
- inner = outer - priv->ring_width;
-
- dx = x - center;
- dy = center - y;
- dist = dx * dx + dy * dy;
-
- return (dist >= inner * inner && dist <= outer * outer);
+ HSVPrivate *priv;
+ gdouble dx, dy, dist;
+ gdouble center, inner, outer;
+
+ priv = hsv->priv;
+
+ center = priv->size / 2.0;
+ outer = priv->size / 2.0;
+ inner = outer - priv->ring_width;
+
+ dx = x - center;
+ dy = center - y;
+ dist = dx * dx + dy * dy;
+
+ return (dist >= inner * inner && dist <= outer * outer);
}
/* Computes a saturation/value pair based on the mouse coordinates */
static void
-compute_sv (GtkHSV *hsv, double x, double y, double *s, double *v)
+compute_sv (GtkHSV *hsv,
+ gdouble x,
+ gdouble y,
+ gdouble *s,
+ gdouble *v)
{
- HSVPrivate *priv;
- int ihx, ihy, isx, isy, ivx, ivy;
- double hx, hy, sx, sy, vx, vy;
- double center;
-
- priv = hsv->priv;
-
- compute_triangle (hsv, &ihx, &ihy, &isx, &isy, &ivx, &ivy);
- center = priv->size / 2.0;
- hx = ihx - center;
- hy = center - ihy;
- sx = isx - center;
- sy = center - isy;
- vx = ivx - center;
- vy = center - ivy;
- x -= center;
- y = center - y;
-
- if (vx * (x - sx) + vy * (y - sy) < 0.0) {
- *s = 1.0;
- *v = (((x - sx) * (hx - sx) + (y - sy) * (hy-sy))
- / ((hx - sx) * (hx - sx) + (hy - sy) * (hy - sy)));
-
- if (*v < 0.0)
- *v = 0.0;
- else if (*v > 1.0)
- *v = 1.0;
- } else if (hx * (x - sx) + hy * (y - sy) < 0.0) {
- *s = 0.0;
- *v = (((x - sx) * (vx - sx) + (y - sy) * (vy - sy))
- / ((vx - sx) * (vx - sx) + (vy - sy) * (vy - sy)));
-
- if (*v < 0.0)
- *v = 0.0;
- else if (*v > 1.0)
- *v = 1.0;
- } else if (sx * (x - hx) + sy * (y - hy) < 0.0) {
- *v = 1.0;
- *s = (((x - vx) * (hx - vx) + (y - vy) * (hy - vy)) /
- ((hx - vx) * (hx - vx) + (hy - vy) * (hy - vy)));
-
- if (*s < 0.0)
- *s = 0.0;
- else if (*s > 1.0)
- *s = 1.0;
- } else {
- *v = (((x - sx) * (hy - vy) - (y - sy) * (hx - vx))
- / ((vx - sx) * (hy - vy) - (vy - sy) * (hx - vx)));
-
- if (*v<= 0.0) {
- *v = 0.0;
- *s = 0.0;
- } else {
- if (*v > 1.0)
- *v = 1.0;
-
- *s = (y - sy - *v * (vy - sy)) / (*v * (hy - vy));
- if (*s < 0.0)
- *s = 0.0;
- else if (*s > 1.0)
- *s = 1.0;
- }
+ HSVPrivate *priv;
+ int ihx, ihy, isx, isy, ivx, ivy;
+ double hx, hy, sx, sy, vx, vy;
+ double center;
+
+ priv = hsv->priv;
+
+ compute_triangle (hsv, &ihx, &ihy, &isx, &isy, &ivx, &ivy);
+ center = priv->size / 2.0;
+ hx = ihx - center;
+ hy = center - ihy;
+ sx = isx - center;
+ sy = center - isy;
+ vx = ivx - center;
+ vy = center - ivy;
+ x -= center;
+ y = center - y;
+
+ if (vx * (x - sx) + vy * (y - sy) < 0.0)
+ {
+ *s = 1.0;
+ *v = (((x - sx) * (hx - sx) + (y - sy) * (hy-sy))
+ / ((hx - sx) * (hx - sx) + (hy - sy) * (hy - sy)));
+
+ if (*v < 0.0)
+ *v = 0.0;
+ else if (*v > 1.0)
+ *v = 1.0;
+ }
+ else if (hx * (x - sx) + hy * (y - sy) < 0.0)
+ {
+ *s = 0.0;
+ *v = (((x - sx) * (vx - sx) + (y - sy) * (vy - sy))
+ / ((vx - sx) * (vx - sx) + (vy - sy) * (vy - sy)));
+
+ if (*v < 0.0)
+ *v = 0.0;
+ else if (*v > 1.0)
+ *v = 1.0;
+ }
+ else if (sx * (x - hx) + sy * (y - hy) < 0.0)
+ {
+ *v = 1.0;
+ *s = (((x - vx) * (hx - vx) + (y - vy) * (hy - vy)) /
+ ((hx - vx) * (hx - vx) + (hy - vy) * (hy - vy)));
+
+ if (*s < 0.0)
+ *s = 0.0;
+ else if (*s > 1.0)
+ *s = 1.0;
+ }
+ else
+ {
+ *v = (((x - sx) * (hy - vy) - (y - sy) * (hx - vx))
+ / ((vx - sx) * (hy - vy) - (vy - sy) * (hx - vx)));
+
+ if (*v<= 0.0)
+ {
+ *v = 0.0;
+ *s = 0.0;
+ }
+ else
+ {
+ if (*v > 1.0)
+ *v = 1.0;
+
+ *s = (y - sy - *v * (vy - sy)) / (*v * (hy - vy));
+ if (*s < 0.0)
+ *s = 0.0;
+ else if (*s > 1.0)
+ *s = 1.0;
}
+ }
}
/* Computes whether a point is inside the saturation/value triangle */
static gboolean
-is_in_triangle (GtkHSV *hsv, double x, double y)
+is_in_triangle (GtkHSV *hsv,
+ gdouble x,
+ gdouble y)
{
- int hx, hy, sx, sy, vx, vy;
- double det, s, v;
-
- compute_triangle (hsv, &hx, &hy, &sx, &sy, &vx, &vy);
-
- det = (vx - sx) * (hy - sy) - (vy - sy) * (hx - sx);
-
- s = ((x - sx) * (hy - sy) - (y - sy) * (hx - sx)) / det;
- v = ((vx - sx) * (y - sy) - (vy - sy) * (x - sx)) / det;
-
- return (s >= 0.0 && v >= 0.0 && s + v <= 1.0);
+ int hx, hy, sx, sy, vx, vy;
+ double det, s, v;
+
+ compute_triangle (hsv, &hx, &hy, &sx, &sy, &vx, &vy);
+
+ det = (vx - sx) * (hy - sy) - (vy - sy) * (hx - sx);
+
+ s = ((x - sx) * (hy - sy) - (y - sy) * (hx - sx)) / det;
+ v = ((vx - sx) * (y - sy) - (vy - sy) * (x - sx)) / det;
+
+ return (s >= 0.0 && v >= 0.0 && s + v <= 1.0);
}
/* Computes a value based on the mouse coordinates */
static double
-compute_v (GtkHSV *hsv, double x, double y)
+compute_v (GtkHSV *hsv,
+ gdouble x,
+ gdouble y)
{
- HSVPrivate *priv;
- double center;
- double dx, dy;
- double angle;
-
- priv = hsv->priv;
-
- center = priv->size / 2.0;
- dx = x - center;
- dy = center - y;
-
- angle = atan2 (dy, dx);
- if (angle < 0.0)
- angle += 2.0 * M_PI;
-
- return angle / (2.0 * M_PI);
+ HSVPrivate *priv;
+ double center;
+ double dx, dy;
+ double angle;
+
+ priv = hsv->priv;
+
+ center = priv->size / 2.0;
+ dx = x - center;
+ dy = center - y;
+
+ angle = atan2 (dy, dx);
+ if (angle < 0.0)
+ angle += 2.0 * M_PI;
+
+ return angle / (2.0 * M_PI);
}
-\f
-
/* Event handlers */
static void
-set_cross_grab (GtkHSV *hsv, guint32 time)
+set_cross_grab (GtkHSV *hsv,
+ guint32 time)
{
- HSVPrivate *priv;
- GdkCursor *cursor;
-
- priv = hsv->priv;
-
- cursor = gdk_cursor_new (GDK_CROSSHAIR);
- gdk_pointer_grab (priv->window, FALSE,
- (GDK_POINTER_MOTION_MASK
- | GDK_POINTER_MOTION_HINT_MASK
- | GDK_BUTTON_RELEASE_MASK),
- NULL,
- cursor,
- time);
- gdk_cursor_destroy (cursor);
-
+ HSVPrivate *priv;
+ GdkCursor *cursor;
+
+ priv = hsv->priv;
+
+ cursor = gdk_cursor_new (GDK_CROSSHAIR);
+ gdk_pointer_grab (priv->window, FALSE,
+ (GDK_POINTER_MOTION_MASK
+ | GDK_POINTER_MOTION_HINT_MASK
+ | GDK_BUTTON_RELEASE_MASK),
+ NULL,
+ cursor,
+ time);
+ gdk_cursor_destroy (cursor);
}
/* Button_press_event handler for the HSV color selector */
static gint
-gtk_hsv_button_press (GtkWidget *widget, GdkEventButton *event)
+gtk_hsv_button_press (GtkWidget *widget,
+ GdkEventButton *event)
{
- GtkHSV *hsv;
- HSVPrivate *priv;
- double x, y;
-
- hsv = GTK_HSV (widget);
- priv = hsv->priv;
-
- if (priv->mode != DRAG_NONE || event->button != 1)
- return FALSE;
-
- x = event->x;
- y = event->y;
-
- if (is_in_ring (hsv, x, y)) {
- priv->mode = DRAG_H;
- set_cross_grab (hsv, event->time);
-
- gtk_hsv_set_color (hsv,
- compute_v (hsv, x, y),
- priv->s,
- priv->v);
-
- return TRUE;
- }
-
- if (is_in_triangle (hsv, x, y)) {
- double s, v;
-
- priv->mode = DRAG_SV;
- set_cross_grab (hsv, event->time);
-
- compute_sv (hsv, x, y, &s, &v);
- gtk_hsv_set_color (hsv, priv->h, s, v);
- return TRUE;
- }
-
- return FALSE;
+ GtkHSV *hsv;
+ HSVPrivate *priv;
+ double x, y;
+
+ hsv = GTK_HSV (widget);
+ priv = hsv->priv;
+
+ if (priv->mode != DRAG_NONE || event->button != 1)
+ return FALSE;
+
+ x = event->x;
+ y = event->y;
+
+ if (is_in_ring (hsv, x, y))
+ {
+ priv->mode = DRAG_H;
+ set_cross_grab (hsv, event->time);
+
+ gtk_hsv_set_color (hsv,
+ compute_v (hsv, x, y),
+ priv->s,
+ priv->v);
+
+ return TRUE;
+ }
+
+ if (is_in_triangle (hsv, x, y))
+ {
+ gdouble s, v;
+
+ priv->mode = DRAG_SV;
+ set_cross_grab (hsv, event->time);
+
+ compute_sv (hsv, x, y, &s, &v);
+ gtk_hsv_set_color (hsv, priv->h, s, v);
+ return TRUE;
+ }
+
+ return FALSE;
}
/* Button_release_event handler for the HSV color selector */
static gint
-gtk_hsv_button_release (GtkWidget *widget, GdkEventButton *event)
+gtk_hsv_button_release (GtkWidget *widget,
+ GdkEventButton *event)
{
- GtkHSV *hsv;
- HSVPrivate *priv;
- DragMode mode;
- double x, y;
-
- hsv = GTK_HSV (widget);
- priv = hsv->priv;
-
- if (priv->mode == DRAG_NONE || event->button != 1)
- return FALSE;
-
- /* Set the drag mode to DRAG_NONE so that signal handlers for "catched"
- * can see that this is the final color state.
- */
-
- mode = priv->mode;
- priv->mode = DRAG_NONE;
-
- x = event->x;
- y = event->y;
-
- if (mode == DRAG_H)
- gtk_hsv_set_color (hsv, compute_v (hsv, x, y), priv->s, priv->v);
- else if (mode == DRAG_SV) {
- double s, v;
-
- compute_sv (hsv, x, y, &s, &v);
- gtk_hsv_set_color (hsv, priv->h, s, v);
- } else
- g_assert_not_reached ();
-
- gdk_pointer_ungrab (event->time);
-
- return TRUE;
+ GtkHSV *hsv;
+ HSVPrivate *priv;
+ DragMode mode;
+ gdouble x, y;
+
+ hsv = GTK_HSV (widget);
+ priv = hsv->priv;
+
+ if (priv->mode == DRAG_NONE || event->button != 1)
+ return FALSE;
+
+ /* Set the drag mode to DRAG_NONE so that signal handlers for "catched"
+ * can see that this is the final color state.
+ */
+
+ mode = priv->mode;
+ priv->mode = DRAG_NONE;
+
+ x = event->x;
+ y = event->y;
+
+ if (mode == DRAG_H)
+ gtk_hsv_set_color (hsv, compute_v (hsv, x, y), priv->s, priv->v);
+ else if (mode == DRAG_SV) {
+ double s, v;
+
+ compute_sv (hsv, x, y, &s, &v);
+ gtk_hsv_set_color (hsv, priv->h, s, v);
+ } else
+ g_assert_not_reached ();
+
+ gdk_pointer_ungrab (event->time);
+
+ return TRUE;
}
/* Motion_notify_event handler for the HSV color selector */
static gint
-gtk_hsv_motion (GtkWidget *widget, GdkEventMotion *event)
+gtk_hsv_motion (GtkWidget *widget,
+ GdkEventMotion *event)
{
- GtkHSV *hsv;
- HSVPrivate *priv;
- double x, y;
- gint ix, iy;
- GdkModifierType mods;
-
- hsv = GTK_HSV (widget);
- priv = hsv->priv;
-
- if (priv->mode == DRAG_NONE)
- return FALSE;
-
- if (event->is_hint) {
- gdk_window_get_pointer (priv->window, &ix, &iy, &mods);
- x = ix;
- y = iy;
- } else {
- x = event->x;
- y = event->y;
- }
-
- if (priv->mode == DRAG_H) {
- gtk_hsv_set_color (hsv, compute_v (hsv, x, y), priv->s, priv->v);
- return TRUE;
- } else if (priv->mode == DRAG_SV) {
- double s, v;
-
- compute_sv (hsv, x, y, &s, &v);
- gtk_hsv_set_color (hsv, priv->h, s, v);
- return TRUE;
- }
-
- g_assert_not_reached ();
- return FALSE;
+ GtkHSV *hsv;
+ HSVPrivate *priv;
+ double x, y;
+ gint ix, iy;
+ GdkModifierType mods;
+
+ hsv = GTK_HSV (widget);
+ priv = hsv->priv;
+
+ if (priv->mode == DRAG_NONE)
+ return FALSE;
+
+ if (event->is_hint)
+ {
+ gdk_window_get_pointer (priv->window, &ix, &iy, &mods);
+ x = ix;
+ y = iy;
+ }
+ else
+ {
+ x = event->x;
+ y = event->y;
+ }
+
+ if (priv->mode == DRAG_H)
+ {
+ gtk_hsv_set_color (hsv, compute_v (hsv, x, y), priv->s, priv->v);
+ return TRUE;
+ }
+ else if (priv->mode == DRAG_SV)
+ {
+ double s, v;
+
+ compute_sv (hsv, x, y, &s, &v);
+ gtk_hsv_set_color (hsv, priv->h, s, v);
+ return TRUE;
+ }
+
+ g_assert_not_reached ();
+ return FALSE;
}
-\f
/* Redrawing */
/* Paints the hue ring */
static void
-paint_ring (GtkHSV *hsv, GdkDrawable *drawable, int x, int y, int width, int height)
+paint_ring (GtkHSV *hsv,
+ GdkDrawable *drawable,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
{
- HSVPrivate *priv;
- int xx, yy;
- double dx, dy, dist;
- double center;
- double inner, outer;
- guchar *buf, *p;
- double angle;
- double hue;
- double r, g, b;
- GdkBitmap *mask;
- GdkGC *gc;
- GdkColor color;
-
- priv = hsv->priv;
-
- center = priv->size / 2.0;
-
- outer = priv->size / 2.0;
- inner = outer - priv->ring_width;
-
- /* Paint the ring */
-
- buf = g_new (guchar, width * height * 3);
-
- for (yy = 0; yy < height; yy++) {
- p = buf + yy * width * 3;
-
- dy = -(yy + y - center);
-
- for (xx = 0; xx < width; xx++) {
- dx = xx + x - center;
-
- dist = dx * dx + dy * dy;
- if (dist < (inner * inner) || dist > (outer * outer)) {
- *p++ = 0;
- *p++ = 0;
- *p++ = 0;
- continue;
- }
-
- angle = atan2 (dy, dx);
- if (angle < 0.0)
- angle += 2.0 * M_PI;
-
- hue = angle / (2.0 * M_PI);
-
- r = hue;
- g = 1.0;
- b = 1.0;
- hsv_to_rgb (&r, &g, &b);
-
- *p++ = floor (r * 255 + 0.5);
- *p++ = floor (g * 255 + 0.5);
- *p++ = floor (b * 255 + 0.5);
- }
+ HSVPrivate *priv;
+ int xx, yy;
+ gdouble dx, dy, dist;
+ gdouble center;
+ gdouble inner, outer;
+ guchar *buf, *p;
+ gdouble angle;
+ gdouble hue;
+ gdouble r, g, b;
+ GdkBitmap *mask;
+ GdkGC *gc;
+ GdkColor color;
+
+ priv = hsv->priv;
+
+ center = priv->size / 2.0;
+
+ outer = priv->size / 2.0;
+ inner = outer - priv->ring_width;
+
+ /* Paint the ring */
+
+ buf = g_new (guchar, width * height * 3);
+
+ for (yy = 0; yy < height; yy++)
+ {
+ p = buf + yy * width * 3;
+
+ dy = -(yy + y - center);
+
+ for (xx = 0; xx < width; xx++)
+ {
+ dx = xx + x - center;
+
+ dist = dx * dx + dy * dy;
+ if (dist < (inner * inner) || dist > (outer * outer))
+ {
+ *p++ = 0;
+ *p++ = 0;
+ *p++ = 0;
+ continue;
+ }
+
+ angle = atan2 (dy, dx);
+ if (angle < 0.0)
+ angle += 2.0 * M_PI;
+
+ hue = angle / (2.0 * M_PI);
+
+ r = hue;
+ g = 1.0;
+ b = 1.0;
+ hsv_to_rgb (&r, &g, &b);
+
+ *p++ = floor (r * 255 + 0.5);
+ *p++ = floor (g * 255 + 0.5);
+ *p++ = floor (b * 255 + 0.5);
}
-
- /* Create clipping mask */
-
- mask = gdk_pixmap_new (NULL, width, height, 1);
- gc = gdk_gc_new (mask);
-
- color.pixel = 0;
- gdk_gc_set_foreground (gc, &color);
- gdk_draw_rectangle (mask, gc, TRUE,
- 0, 0, width, height);
-
-
- color.pixel = 1;
- gdk_gc_set_foreground (gc, &color);
- gdk_draw_arc (mask, gc, TRUE,
- -x, -y,
- priv->size - 1, priv->size - 1,
- 0, 360 * 64);
-
- color.pixel = 0;
- gdk_gc_set_foreground (gc, &color);
- gdk_draw_arc (mask, gc, TRUE,
- -x + priv->ring_width - 1, -y + priv->ring_width - 1,
- priv->size - 2 * priv->ring_width + 1, priv->size - 2 * priv->ring_width + 1,
- 0, 360 * 64);
-
- gdk_gc_unref (gc);
-
- gdk_gc_set_clip_mask (priv->gc, mask);
- gdk_gc_set_clip_origin (priv->gc, 0, 0);
-
- /* Draw ring */
-
- gdk_draw_rgb_image_dithalign (drawable, priv->gc, 0, 0, width, height,
- GDK_RGB_DITHER_MAX,
- buf,
- width * 3,
- x, y);
-
- /* Draw value marker */
-
- r = priv->h;
- g = 1.0;
- b = 1.0;
- hsv_to_rgb (&r, &g, &b);
-
- if (INTENSITY (r, g, b) > 0.5)
- gdk_rgb_gc_set_foreground (priv->gc, 0x000000);
- else
- gdk_rgb_gc_set_foreground (priv->gc, 0xffffff);
-
- gdk_draw_line (drawable, priv->gc,
- -x + center, -y + center,
- -x + center + cos (priv->h * 2.0 * M_PI) * center,
- -y + center - sin (priv->h * 2.0 * M_PI) * center);
-
- gdk_gc_set_clip_mask (priv->gc, NULL);
- gdk_bitmap_unref (mask);
-
- g_free (buf);
-
- /* Draw ring outline */
-
- gdk_rgb_gc_set_foreground (priv->gc, 0x000000);
-
- gdk_draw_arc (drawable, priv->gc, FALSE,
- -x, -y,
- priv->size - 1, priv->size - 1,
- 0, 360 * 64);
- gdk_draw_arc (drawable, priv->gc, FALSE,
- -x + priv->ring_width - 1, -y + priv->ring_width - 1,
- priv->size - 2 * priv->ring_width + 1, priv->size - 2 * priv->ring_width + 1,
- 0, 360 * 64);
+ }
+
+ /* Create clipping mask */
+
+ mask = gdk_pixmap_new (NULL, width, height, 1);
+ gc = gdk_gc_new (mask);
+
+ color.pixel = 0;
+ gdk_gc_set_foreground (gc, &color);
+ gdk_draw_rectangle (mask, gc, TRUE,
+ 0, 0, width, height);
+
+
+ color.pixel = 1;
+ gdk_gc_set_foreground (gc, &color);
+ gdk_draw_arc (mask, gc, TRUE,
+ -x, -y,
+ priv->size - 1, priv->size - 1,
+ 0, 360 * 64);
+
+ color.pixel = 0;
+ gdk_gc_set_foreground (gc, &color);
+ gdk_draw_arc (mask, gc, TRUE,
+ -x + priv->ring_width - 1, -y + priv->ring_width - 1,
+ priv->size - 2 * priv->ring_width + 1, priv->size - 2 * priv->ring_width + 1,
+ 0, 360 * 64);
+
+ gdk_gc_unref (gc);
+
+ gdk_gc_set_clip_mask (priv->gc, mask);
+ gdk_gc_set_clip_origin (priv->gc, 0, 0);
+
+ /* Draw ring */
+
+ gdk_draw_rgb_image_dithalign (drawable, priv->gc, 0, 0, width, height,
+ GDK_RGB_DITHER_MAX,
+ buf,
+ width * 3,
+ x, y);
+
+ /* Draw value marker */
+
+ r = priv->h;
+ g = 1.0;
+ b = 1.0;
+ hsv_to_rgb (&r, &g, &b);
+
+ if (INTENSITY (r, g, b) > 0.5)
+ gdk_rgb_gc_set_foreground (priv->gc, 0x000000);
+ else
+ gdk_rgb_gc_set_foreground (priv->gc, 0xffffff);
+
+ gdk_draw_line (drawable, priv->gc,
+ -x + center, -y + center,
+ -x + center + cos (priv->h * 2.0 * M_PI) * center,
+ -y + center - sin (priv->h * 2.0 * M_PI) * center);
+
+ gdk_gc_set_clip_mask (priv->gc, NULL);
+ gdk_bitmap_unref (mask);
+
+ g_free (buf);
+
+ /* Draw ring outline */
+
+ gdk_rgb_gc_set_foreground (priv->gc, 0x000000);
+
+ gdk_draw_arc (drawable, priv->gc, FALSE,
+ -x, -y,
+ priv->size - 1, priv->size - 1,
+ 0, 360 * 64);
+ gdk_draw_arc (drawable, priv->gc, FALSE,
+ -x + priv->ring_width - 1, -y + priv->ring_width - 1,
+ priv->size - 2 * priv->ring_width + 1, priv->size - 2 * priv->ring_width + 1,
+ 0, 360 * 64);
}
/* Converts an HSV triplet to an integer RGB triplet */
static void
-get_color (double h, double s, double v, int *r, int *g, int *b)
+get_color (gdouble h,
+ gdouble s,
+ gdouble v,
+ gint *r,
+ gint *g,
+ gint *b)
{
- hsv_to_rgb (&h, &s, &v);
-
- *r = floor (h * 255 + 0.5);
- *g = floor (s * 255 + 0.5);
- *b = floor (v * 255 + 0.5);
+ hsv_to_rgb (&h, &s, &v);
+
+ *r = floor (h * 255 + 0.5);
+ *g = floor (s * 255 + 0.5);
+ *b = floor (v * 255 + 0.5);
}
#define SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t))
/* Paints the HSV triangle */
static void
-paint_triangle (GtkHSV *hsv, GdkDrawable *drawable, int x, int y, int width, int height)
+paint_triangle (GtkHSV *hsv,
+ GdkDrawable *drawable,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
{
- HSVPrivate *priv;
- int hx, hy, sx, sy, vx, vy; /* HSV vertices */
- int x1, y1, r1, g1, b1; /* First vertex in scanline order */
- int x2, y2, r2, g2, b2; /* Second vertex */
- int x3, y3, r3, g3, b3; /* Third vertex */
- int t;
- guchar *buf, *p;
- int xl, xr, rl, rr, gl, gr, bl, br; /* Scanline data */
- int xx, yy;
- GdkBitmap *mask;
- GdkGC *gc;
- GdkColor color;
- GdkPoint points[3];
- double r, g, b;
-
- priv = hsv->priv;
-
- /* Compute triangle's vertices */
-
- compute_triangle (hsv, &hx, &hy, &sx, &sy, &vx, &vy);
-
- x1 = hx;
- y1 = hy;
- get_color (priv->h, 1.0, 1.0, &r1, &g1, &b1);
-
- x2 = sx;
- y2 = sy;
- get_color (priv->h, 1.0, 0.0, &r2, &g2, &b2);
-
- x3 = vx;
- y3 = vy;
- get_color (priv->h, 0.0, 1.0, &r3, &g3, &b3);
-
- if (y2 > y3) {
- SWAP (x2, x3, t);
- SWAP (y2, y3, t);
- SWAP (r2, r3, t);
- SWAP (g2, g3, t);
- SWAP (b2, b3, t);
- }
-
- if (y1 > y3) {
- SWAP (x1, x3, t);
- SWAP (y1, y3, t);
- SWAP (r1, r3, t);
- SWAP (g1, g3, t);
- SWAP (b1, b3, t);
- }
-
- if (y1 > y2) {
- SWAP (x1, x2, t);
- SWAP (y1, y2, t);
- SWAP (r1, r2, t);
- SWAP (g1, g2, t);
- SWAP (b1, b2, t);
- }
-
- /* Shade the triangle */
-
- buf = g_new (guchar, width * height * 3);
-
- for (yy = 0; yy < height; yy++) {
- p = buf + yy * width * 3;
-
- if (yy + y < y1 || yy + y > y3)
- for (xx = 0; xx < width; xx++) {
- *p++ = 0;
- *p++ = 0;
- *p++ = 0;
- }
- else {
- if (yy + y < y2) {
- xl = LERP (x1, x2, y1, y2, yy + y);
-
- rl = LERP (r1, r2, y1, y2, yy + y);
- gl = LERP (g1, g2, y1, y2, yy + y);
- bl = LERP (b1, b2, y1, y2, yy + y);
- } else {
- xl = LERP (x2, x3, y2, y3, yy + y);
-
- rl = LERP (r2, r3, y2, y3, yy + y);
- gl = LERP (g2, g3, y2, y3, yy + y);
- bl = LERP (b2, b3, y2, y3, yy + y);
- }
-
- xr = LERP (x1, x3, y1, y3, yy + y);
-
- rr = LERP (r1, r3, y1, y3, yy + y);
- gr = LERP (g1, g3, y1, y3, yy + y);
- br = LERP (b1, b3, y1, y3, yy + y);
-
- if (xl > xr) {
- SWAP (xl, xr, t);
- SWAP (rl, rr, t);
- SWAP (gl, gr, t);
- SWAP (bl, br, t);
- }
-
- for (xx = 0; xx < width; xx++) {
- if (xx + x < xl || xx + x > xr) {
- *p++ = 0;
- *p++ = 0;
- *p++ = 0;
- } else {
- *p++ = LERP (rl, rr, xl, xr, xx + x);
- *p++ = LERP (gl, gr, xl, xr, xx + x);
- *p++ = LERP (bl, br, xl, xr, xx + x);
- }
- }
- }
- }
-
- /* Create clipping mask */
-
- mask = gdk_pixmap_new (NULL, width, height, 1);
- gc = gdk_gc_new (mask);
-
- color.pixel = 0;
- gdk_gc_set_foreground (gc, &color);
- gdk_draw_rectangle (mask, gc, TRUE,
- 0, 0, width, height);
-
- color.pixel = 1;
- gdk_gc_set_foreground (gc, &color);
-
- points[0].x = x1 - x;
- points[0].y = y1 - y;
- points[1].x = x2 - x;
- points[1].y = y2 - y;
- points[2].x = x3 - x;
- points[2].y = y3 - y;
- gdk_draw_polygon (mask, gc, TRUE, points, 3);
-
- gdk_gc_unref (gc);
-
- gdk_gc_set_clip_mask (priv->gc, mask);
- gdk_gc_set_clip_origin (priv->gc, 0, 0);
-
- /* Draw triangle */
-
- gdk_draw_rgb_image_dithalign (drawable, priv->gc, 0, 0, width, height,
- GDK_RGB_DITHER_MAX,
- buf,
- width * 3,
- x, y);
-
- gdk_gc_set_clip_mask (priv->gc, NULL);
- gdk_bitmap_unref (mask);
-
- g_free (buf);
-
- /* Draw triangle outline */
-
- gdk_rgb_gc_set_foreground (priv->gc, 0x000000);
-
- gdk_draw_polygon (drawable, priv->gc, FALSE, points, 3);
-
- /* Draw value marker */
-
- xx = floor (sx + (vx - sx) * priv->v + (hx - vx) * priv->s * priv->v + 0.5);
- yy = floor (sy + (vy - sy) * priv->v + (hy - vy) * priv->s * priv->v + 0.5);
-
- r = priv->h;
- g = priv->s;
- b = priv->v;
- hsv_to_rgb (&r, &g, &b);
-
- if (INTENSITY (r, g, b) > 0.5)
- gdk_rgb_gc_set_foreground (priv->gc, 0x000000);
+ HSVPrivate *priv;
+ gint hx, hy, sx, sy, vx, vy; /* HSV vertices */
+ gint x1, y1, r1, g1, b1; /* First vertex in scanline order */
+ gint x2, y2, r2, g2, b2; /* Second vertex */
+ gint x3, y3, r3, g3, b3; /* Third vertex */
+ gint t;
+ guchar *buf, *p;
+ gint xl, xr, rl, rr, gl, gr, bl, br; /* Scanline data */
+ gint xx, yy;
+ GdkBitmap *mask;
+ GdkGC *gc;
+ GdkColor color;
+ GdkPoint points[3];
+ gdouble r, g, b;
+
+ priv = hsv->priv;
+
+ /* Compute triangle's vertices */
+
+ compute_triangle (hsv, &hx, &hy, &sx, &sy, &vx, &vy);
+
+ x1 = hx;
+ y1 = hy;
+ get_color (priv->h, 1.0, 1.0, &r1, &g1, &b1);
+
+ x2 = sx;
+ y2 = sy;
+ get_color (priv->h, 1.0, 0.0, &r2, &g2, &b2);
+
+ x3 = vx;
+ y3 = vy;
+ get_color (priv->h, 0.0, 1.0, &r3, &g3, &b3);
+
+ if (y2 > y3)
+ {
+ SWAP (x2, x3, t);
+ SWAP (y2, y3, t);
+ SWAP (r2, r3, t);
+ SWAP (g2, g3, t);
+ SWAP (b2, b3, t);
+ }
+
+ if (y1 > y3)
+ {
+ SWAP (x1, x3, t);
+ SWAP (y1, y3, t);
+ SWAP (r1, r3, t);
+ SWAP (g1, g3, t);
+ SWAP (b1, b3, t);
+ }
+
+ if (y1 > y2)
+ {
+ SWAP (x1, x2, t);
+ SWAP (y1, y2, t);
+ SWAP (r1, r2, t);
+ SWAP (g1, g2, t);
+ SWAP (b1, b2, t);
+ }
+
+ /* Shade the triangle */
+
+ buf = g_new (guchar, width * height * 3);
+
+ for (yy = 0; yy < height; yy++)
+ {
+ p = buf + yy * width * 3;
+
+ if (yy + y < y1 || yy + y > y3)
+ for (xx = 0; xx < width; xx++)
+ {
+ *p++ = 0;
+ *p++ = 0;
+ *p++ = 0;
+ }
+ else {
+ if (yy + y < y2)
+ {
+ xl = LERP (x1, x2, y1, y2, yy + y);
+
+ rl = LERP (r1, r2, y1, y2, yy + y);
+ gl = LERP (g1, g2, y1, y2, yy + y);
+ bl = LERP (b1, b2, y1, y2, yy + y);
+ }
else
- gdk_rgb_gc_set_foreground (priv->gc, 0xffffff);
-
- gdk_draw_arc (drawable, priv->gc, FALSE,
- xx - 3, yy - 3,
- 6, 6,
- 0, 360 * 64);
- gdk_draw_arc (drawable, priv->gc, FALSE,
- xx - 2, yy - 2,
- 4, 4,
- 0, 360 * 64);
+ {
+ xl = LERP (x2, x3, y2, y3, yy + y);
+
+ rl = LERP (r2, r3, y2, y3, yy + y);
+ gl = LERP (g2, g3, y2, y3, yy + y);
+ bl = LERP (b2, b3, y2, y3, yy + y);
+ }
+
+ xr = LERP (x1, x3, y1, y3, yy + y);
+
+ rr = LERP (r1, r3, y1, y3, yy + y);
+ gr = LERP (g1, g3, y1, y3, yy + y);
+ br = LERP (b1, b3, y1, y3, yy + y);
+
+ if (xl > xr)
+ {
+ SWAP (xl, xr, t);
+ SWAP (rl, rr, t);
+ SWAP (gl, gr, t);
+ SWAP (bl, br, t);
+ }
+
+ for (xx = 0; xx < width; xx++)
+ {
+ if (xx + x < xl || xx + x > xr)
+ {
+ *p++ = 0;
+ *p++ = 0;
+ *p++ = 0;
+ }
+ else
+ {
+ *p++ = LERP (rl, rr, xl, xr, xx + x);
+ *p++ = LERP (gl, gr, xl, xr, xx + x);
+ *p++ = LERP (bl, br, xl, xr, xx + x);
+ }
+ }
+ }
+ }
+
+ /* Create clipping mask */
+
+ mask = gdk_pixmap_new (NULL, width, height, 1);
+ gc = gdk_gc_new (mask);
+
+ color.pixel = 0;
+ gdk_gc_set_foreground (gc, &color);
+ gdk_draw_rectangle (mask, gc, TRUE,
+ 0, 0, width, height);
+
+ color.pixel = 1;
+ gdk_gc_set_foreground (gc, &color);
+
+ points[0].x = x1 - x;
+ points[0].y = y1 - y;
+ points[1].x = x2 - x;
+ points[1].y = y2 - y;
+ points[2].x = x3 - x;
+ points[2].y = y3 - y;
+ gdk_draw_polygon (mask, gc, TRUE, points, 3);
+
+ gdk_gc_unref (gc);
+
+ gdk_gc_set_clip_mask (priv->gc, mask);
+ gdk_gc_set_clip_origin (priv->gc, 0, 0);
+
+ /* Draw triangle */
+
+ gdk_draw_rgb_image_dithalign (drawable, priv->gc, 0, 0, width, height,
+ GDK_RGB_DITHER_MAX,
+ buf,
+ width * 3,
+ x, y);
+
+ gdk_gc_set_clip_mask (priv->gc, NULL);
+ gdk_bitmap_unref (mask);
+
+ g_free (buf);
+
+ /* Draw triangle outline */
+
+ gdk_rgb_gc_set_foreground (priv->gc, 0x000000);
+
+ gdk_draw_polygon (drawable, priv->gc, FALSE, points, 3);
+
+ /* Draw value marker */
+
+ xx = floor (sx + (vx - sx) * priv->v + (hx - vx) * priv->s * priv->v + 0.5);
+ yy = floor (sy + (vy - sy) * priv->v + (hy - vy) * priv->s * priv->v + 0.5);
+
+ r = priv->h;
+ g = priv->s;
+ b = priv->v;
+ hsv_to_rgb (&r, &g, &b);
+
+ if (INTENSITY (r, g, b) > 0.5)
+ gdk_rgb_gc_set_foreground (priv->gc, 0x000000);
+ else
+ gdk_rgb_gc_set_foreground (priv->gc, 0xffffff);
+
+ gdk_draw_arc (drawable, priv->gc, FALSE,
+ xx - 3, yy - 3,
+ 6, 6,
+ 0, 360 * 64);
+ gdk_draw_arc (drawable, priv->gc, FALSE,
+ xx - 2, yy - 2,
+ 4, 4,
+ 0, 360 * 64);
}
/* Paints the contents of the HSV color selector */
static void
-paint (GtkHSV *hsv, GdkDrawable *drawable, int x, int y, int width, int height)
+paint (GtkHSV *hsv,
+ GdkDrawable *drawable,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
{
- paint_ring (hsv, drawable, x, y, width, height);
- paint_triangle (hsv, drawable, x, y, width, height);
+ paint_ring (hsv, drawable, x, y, width, height);
+ paint_triangle (hsv, drawable, x, y, width, height);
}
/* Expose_event handler for the HSV color selector */
static gint
-gtk_hsv_expose (GtkWidget *widget, GdkEventExpose *event)
+gtk_hsv_expose (GtkWidget *widget,
+ GdkEventExpose *event)
{
- GtkHSV *hsv;
- HSVPrivate *priv;
- GdkRectangle rect, dest;
- GdkPixmap *pixmap;
-
- hsv = GTK_HSV (widget);
- priv = hsv->priv;
-
- if (!(GTK_WIDGET_DRAWABLE (widget) && event->window == widget->window))
- return FALSE;
-
- rect.x = widget->allocation.x;
- rect.y = widget->allocation.y;
- rect.width = widget->allocation.width;
- rect.height = widget->allocation.height;
-
- if (!gdk_rectangle_intersect (&event->area, &rect, &dest))
- return FALSE;
-
- pixmap = gdk_pixmap_new (widget->window, dest.width, dest.height,
- gtk_widget_get_visual (widget)->depth);
-
- rect = dest;
- rect.x = 0;
- rect.y = 0;
-
- gdk_draw_rectangle (pixmap,
- widget->style->bg_gc[GTK_WIDGET_STATE (widget)],
- TRUE,
- 0, 0, dest.width, dest.height);
- paint (hsv, pixmap,
- dest.x - widget->allocation.x, dest.y - widget->allocation.y,
- dest.width, dest.height);
-
- gdk_draw_pixmap (widget->window,
- priv->gc,
- pixmap,
- 0, 0,
- dest.x,
- dest.y,
- event->area.width, event->area.height);
-
- gdk_pixmap_unref (pixmap);
-
- return FALSE;
+ GtkHSV *hsv;
+ HSVPrivate *priv;
+ GdkRectangle rect, dest;
+ GdkPixmap *pixmap;
+
+ hsv = GTK_HSV (widget);
+ priv = hsv->priv;
+
+ if (!(GTK_WIDGET_DRAWABLE (widget) && event->window == widget->window))
+ return FALSE;
+
+ rect.x = widget->allocation.x;
+ rect.y = widget->allocation.y;
+ rect.width = widget->allocation.width;
+ rect.height = widget->allocation.height;
+
+ if (!gdk_rectangle_intersect (&event->area, &rect, &dest))
+ return FALSE;
+
+ pixmap = gdk_pixmap_new (widget->window, dest.width, dest.height,
+ gtk_widget_get_visual (widget)->depth);
+
+ rect = dest;
+ rect.x = 0;
+ rect.y = 0;
+
+ gdk_draw_rectangle (pixmap,
+ widget->style->bg_gc[GTK_WIDGET_STATE (widget)],
+ TRUE,
+ 0, 0, dest.width, dest.height);
+ paint (hsv, pixmap,
+ dest.x - widget->allocation.x, dest.y - widget->allocation.y,
+ dest.width, dest.height);
+
+ gdk_draw_pixmap (widget->window,
+ priv->gc,
+ pixmap,
+ 0, 0,
+ dest.x,
+ dest.y,
+ event->area.width, event->area.height);
+
+ gdk_pixmap_unref (pixmap);
+
+ return FALSE;
}
-\f
/**
* gtk_hsv_new:
*
* Return value: A newly-created HSV color selector.
**/
-GtkWidget *
+GtkWidget*
gtk_hsv_new (void)
{
- return GTK_WIDGET (gtk_type_new (gtk_hsv_get_type ()));
+ return GTK_WIDGET (gtk_type_new (GTK_TYPE_HSV));
}
/**
* be in the [0.0, 1.0] range.
**/
void
-gtk_hsv_set_color (GtkHSV *hsv, double h, double s, double v)
+gtk_hsv_set_color (GtkHSV *hsv,
+ gdouble h,
+ gdouble s,
+ gdouble v)
{
- HSVPrivate *priv;
-
- g_return_if_fail (hsv != NULL);
- g_return_if_fail (GTK_IS_HSV (hsv));
- g_return_if_fail (h >= 0.0 && h <= 1.0);
- g_return_if_fail (s >= 0.0 && s <= 1.0);
- g_return_if_fail (v >= 0.0 && v <= 1.0);
-
- priv = hsv->priv;
-
- priv->h = h;
- priv->s = s;
- priv->v = v;
-
- gtk_signal_emit (GTK_OBJECT (hsv), hsv_signals[CHANGED]);
-
- gtk_widget_queue_draw (GTK_WIDGET (hsv));
+ HSVPrivate *priv;
+
+ g_return_if_fail (hsv != NULL);
+ g_return_if_fail (GTK_IS_HSV (hsv));
+ g_return_if_fail (h >= 0.0 && h <= 1.0);
+ g_return_if_fail (s >= 0.0 && s <= 1.0);
+ g_return_if_fail (v >= 0.0 && v <= 1.0);
+
+ priv = hsv->priv;
+
+ priv->h = h;
+ priv->s = s;
+ priv->v = v;
+
+ gtk_signal_emit (GTK_OBJECT (hsv), hsv_signals[CHANGED]);
+
+ gtk_widget_queue_draw (GTK_WIDGET (hsv));
}
/**
void
gtk_hsv_get_color (GtkHSV *hsv, double *h, double *s, double *v)
{
- HSVPrivate *priv;
-
- g_return_if_fail (hsv != NULL);
- g_return_if_fail (GTK_IS_HSV (hsv));
-
- priv = hsv->priv;
-
- if (h)
- *h = priv->h;
-
- if (s)
- *s = priv->s;
-
- if (v)
- *v = priv->v;
+ HSVPrivate *priv;
+
+ g_return_if_fail (hsv != NULL);
+ g_return_if_fail (GTK_IS_HSV (hsv));
+
+ priv = hsv->priv;
+
+ if (h)
+ *h = priv->h;
+
+ if (s)
+ *s = priv->s;
+
+ if (v)
+ *v = priv->v;
}
/**
* Sets the size and ring width of an HSV color selector.
**/
void
-gtk_hsv_set_metrics (GtkHSV *hsv, int size, int ring_width)
+gtk_hsv_set_metrics (GtkHSV *hsv,
+ gint size,
+ gint ring_width)
{
- HSVPrivate *priv;
- int same_size;
-
- g_return_if_fail (hsv != NULL);
- g_return_if_fail (GTK_IS_HSV (hsv));
- g_return_if_fail (size > 0);
- g_return_if_fail (ring_width > 0);
- g_return_if_fail (2 * ring_width + 1 <= size);
-
- priv = hsv->priv;
-
- same_size = (priv->size == size);
-
- priv->size = size;
- priv->ring_width = ring_width;
-
- if (same_size)
- gtk_widget_queue_draw (GTK_WIDGET (hsv));
- else
- gtk_widget_queue_resize (GTK_WIDGET (hsv));
+ HSVPrivate *priv;
+ int same_size;
+
+ g_return_if_fail (hsv != NULL);
+ g_return_if_fail (GTK_IS_HSV (hsv));
+ g_return_if_fail (size > 0);
+ g_return_if_fail (ring_width > 0);
+ g_return_if_fail (2 * ring_width + 1 <= size);
+
+ priv = hsv->priv;
+
+ same_size = (priv->size == size);
+
+ priv->size = size;
+ priv->ring_width = ring_width;
+
+ if (same_size)
+ gtk_widget_queue_draw (GTK_WIDGET (hsv));
+ else
+ gtk_widget_queue_resize (GTK_WIDGET (hsv));
}
/**
* Queries the size and ring width of an HSV color selector.
**/
void
-gtk_hsv_get_metrics (GtkHSV *hsv, int *size, int *ring_width)
+gtk_hsv_get_metrics (GtkHSV *hsv,
+ gint *size,
+ gint *ring_width)
{
- HSVPrivate *priv;
-
- g_return_if_fail (hsv != NULL);
- g_return_if_fail (GTK_IS_HSV (hsv));
-
- priv = hsv->priv;
-
- if (size)
- *size = priv->size;
-
- if (ring_width)
- *ring_width = priv->ring_width;
+ HSVPrivate *priv;
+
+ g_return_if_fail (hsv != NULL);
+ g_return_if_fail (GTK_IS_HSV (hsv));
+
+ priv = hsv->priv;
+
+ if (size)
+ *size = priv->size;
+
+ if (ring_width)
+ *ring_width = priv->ring_width;
}
/**
gboolean
gtk_hsv_is_adjusting (GtkHSV *hsv)
{
- HSVPrivate *priv;
-
- g_return_val_if_fail (hsv != NULL, FALSE);
- g_return_val_if_fail (GTK_IS_HSV (hsv), FALSE);
-
- priv = hsv->priv;
- return (priv->mode != DRAG_NONE);
+ HSVPrivate *priv;
+
+ g_return_val_if_fail (hsv != NULL, FALSE);
+ g_return_val_if_fail (GTK_IS_HSV (hsv), FALSE);
+
+ priv = hsv->priv;
+
+ return priv->mode != DRAG_NONE;
}
/**
* [0.0, 1.0] range; output values will be in the same range.
**/
void
-gtk_hsv_to_rgb (double h, double s, double v, double *r, double *g, double *b)
+gtk_hsv_to_rgb (gdouble h,
+ gdouble s,
+ gdouble v,
+ gdouble *r,
+ gdouble *g,
+ gdouble *b)
{
- g_return_if_fail (h >= 0.0 && h <= 1.0);
- g_return_if_fail (s >= 0.0 && s <= 1.0);
- g_return_if_fail (v >= 0.0 && v <= 1.0);
-
- hsv_to_rgb (&h, &s, &v);
-
- if (r)
- *r = h;
-
- if (g)
- *g = s;
-
- if (b)
- *b = v;
+ g_return_if_fail (h >= 0.0 && h <= 1.0);
+ g_return_if_fail (s >= 0.0 && s <= 1.0);
+ g_return_if_fail (v >= 0.0 && v <= 1.0);
+
+ hsv_to_rgb (&h, &s, &v);
+
+ if (r)
+ *r = h;
+
+ if (g)
+ *g = s;
+
+ if (b)
+ *b = v;
}
/**
* [0.0, 1.0] range; output values will be in the same range.
**/
void
-gtk_rgb_to_hsv (double r, double g, double b, double *h, double *s, double *v)
+gtk_rgb_to_hsv (gdouble r,
+ gdouble g,
+ gdouble b,
+ gdouble *h,
+ gdouble *s,
+ gdouble *v)
{
- g_return_if_fail (r >= 0.0 && r <= 1.0);
- g_return_if_fail (g >= 0.0 && g <= 1.0);
- g_return_if_fail (b >= 0.0 && b <= 1.0);
-
- rgb_to_hsv (&r, &g, &b);
-
- if (h)
- *h = r;
-
- if (s)
- *s = g;
-
- if (v)
- *v = b;
+ g_return_if_fail (r >= 0.0 && r <= 1.0);
+ g_return_if_fail (g >= 0.0 && g <= 1.0);
+ g_return_if_fail (b >= 0.0 && b <= 1.0);
+
+ rgb_to_hsv (&r, &g, &b);
+
+ if (h)
+ *h = r;
+
+ if (s)
+ *s = g;
+
+ if (v)
+ *v = b;
}
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
-
#ifndef __GTK_HSV_H__
#define __GTK_HSV_H__
+/*
+ * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
+ * file for a list of people on the GTK+ Team. See the ChangeLog
+ * files for a list of changes. These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+
#ifdef __cplusplus
extern "C" {
#endif
#include <gtk/gtkwidget.h>
-\f
#define GTK_TYPE_HSV (gtk_hsv_get_type ())
#define GTK_HSV(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_HSV, GtkHSV))
#define GTK_HSV_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_HSV, GtkHSV))
#define GTK_IS_HSV(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_HSV))
#define GTK_IS_HSV_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HSV))
+#define GTK_HSV_GET_CLASS(obj) (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_HSV, GtkHSVClass))
-typedef struct _GtkHSV GtkHSV;
+typedef struct _GtkHSV GtkHSV;
typedef struct _GtkHSVClass GtkHSVClass;
-struct _GtkHSV {
- GtkWidget widget;
-
- /* Private data */
- gpointer priv;
+struct _GtkHSV
+{
+ GtkWidget parent_instance;
+
+ /* Private data */
+ gpointer priv;
};
-struct _GtkHSVClass {
- GtkWidgetClass parent_class;
-
- /* Notification signals */
-
- void (* changed) (GtkHSV *hsv);
+struct _GtkHSVClass
+{
+ GtkWidgetClass parent_class;
+
+ /* Notification signals */
+
+ void (*changed) (GtkHSV *hsv);
};
-GtkType gtk_hsv_get_type (void);
+GtkType gtk_hsv_get_type (void);
+GtkWidget* gtk_hsv_new (void);
+void gtk_hsv_set_color (GtkHSV *hsv,
+ double h,
+ double s,
+ double v);
+void gtk_hsv_get_color (GtkHSV *hsv,
+ gdouble *h,
+ gdouble *s,
+ gdouble *v);
+void gtk_hsv_set_metrics (GtkHSV *hsv,
+ gint size,
+ gint ring_width);
+void gtk_hsv_get_metrics (GtkHSV *hsv,
+ gint *size,
+ gint *ring_width);
+gboolean gtk_hsv_is_adjusting (GtkHSV *hsv);
+void gtk_hsv_to_rgb (gdouble h,
+ gdouble s,
+ gdouble v,
+ gdouble *r,
+ gdouble *g,
+ gdouble *b);
+void gtk_rgb_to_hsv (gdouble r,
+ gdouble g,
+ gdouble b,
+ gdouble *h,
+ gdouble *s,
+ gdouble *v);
-GtkWidget *gtk_hsv_new (void);
-
-void gtk_hsv_set_color (GtkHSV *hsv, double h, double s, double v);
-void gtk_hsv_get_color (GtkHSV *hsv, double *h, double *s, double *v);
-
-void gtk_hsv_set_metrics (GtkHSV *hsv, int size, int ring_width);
-void gtk_hsv_get_metrics (GtkHSV *hsv, int *size, int *ring_width);
-
-gboolean gtk_hsv_is_adjusting (GtkHSV *hsv);
-
-void gtk_hsv_to_rgb (double h, double s, double v, double *r, double *g, double *b);
-void gtk_rgb_to_hsv (double r, double g, double b, double *h, double *s, double *v);
-
-\f
#ifdef __cplusplus
}
#endif
-#endif
+#endif /* __GTK_HSV_H__ */
static void gtk_input_dialog_init (GtkInputDialog *inputd);
static GdkDeviceInfo *gtk_input_dialog_get_device_info(guint32 deviceid);
static void gtk_input_dialog_set_device(GtkWidget *widget, gpointer data);
-static void gtk_input_dialog_finalize (GtkObject *object);
static void gtk_input_dialog_set_mapping_mode(GtkWidget *w,
gpointer data);
static void gtk_input_dialog_set_axis(GtkWidget *widget, gpointer data);
input_dialog_signals[ENABLE_DEVICE] =
gtk_signal_new ("enable_device",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkInputDialogClass, enable_device),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1, GTK_TYPE_INT);
input_dialog_signals[DISABLE_DEVICE] =
gtk_signal_new ("disable_device",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkInputDialogClass, disable_device),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1, GTK_TYPE_INT);
LAST_SIGNAL);
- object_class->finalize = gtk_input_dialog_finalize;
klass->enable_device = NULL;
klass->disable_device = NULL;
}
info->mode);
}
-static void
-gtk_input_dialog_finalize (GtkObject *object)
-{
- /* GtkInputDialog *inputd = GTK_INPUT_DIALOG (object); */
-
- /* Clean up ? */
-
- (* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
-}
-
static void
gtk_input_dialog_set_mapping_mode(GtkWidget *w,
gpointer data)
item_signals[SELECT] =
gtk_signal_new ("select",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkItemClass, select),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
item_signals[DESELECT] =
gtk_signal_new ("deselect",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkItemClass, deselect),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
item_signals[TOGGLE] =
gtk_signal_new ("toggle",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkItemClass, toggle),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
static void gtk_item_factory_class_init (GtkItemFactoryClass *klass);
static void gtk_item_factory_init (GtkItemFactory *ifactory);
static void gtk_item_factory_destroy (GtkObject *object);
-static void gtk_item_factory_finalize (GtkObject *object);
+static void gtk_item_factory_finalize (GObject *object);
/* --- static variables --- */
static GtkItemFactoryClass *gtk_item_factory_class = NULL;
-static GtkObjectClass *parent_class = NULL;
+static gpointer parent_class = NULL;
static const gchar *item_factory_string = "Gtk-<ItemFactory>";
static GMemChunk *ifactory_item_chunks = NULL;
static GMemChunk *ifactory_cb_data_chunks = NULL;
static void
gtk_item_factory_class_init (GtkItemFactoryClass *class)
{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
GtkObjectClass *object_class;
gtk_item_factory_class = class;
object_class = (GtkObjectClass*) class;
+ gobject_class->finalize = gtk_item_factory_finalize;
+
object_class->destroy = gtk_item_factory_destroy;
- object_class->finalize = gtk_item_factory_finalize;
class->cpair_comment_single = g_strdup (";\n");
g_return_if_fail (widget != NULL);
g_return_if_fail (item_type != NULL);
- class = GTK_ITEM_FACTORY_CLASS (GTK_OBJECT (ifactory)->klass);
+ class = GTK_ITEM_FACTORY_GET_CLASS (ifactory);
/* set accelerator group on menu widgets
*/
g_slist_free (ifactory->items);
ifactory->items = NULL;
- parent_class->destroy (object);
+ GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
static void
-gtk_item_factory_finalize (GtkObject *object)
+gtk_item_factory_finalize (GObject *object)
{
GtkItemFactory *ifactory;
if (ifactory->translate_notify)
ifactory->translate_notify (ifactory->translate_data);
- parent_class->finalize (object);
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
GtkItemFactory*
g_return_val_if_fail (GTK_IS_ITEM_FACTORY (ifactory), NULL);
g_return_val_if_fail (path != NULL, NULL);
- class = GTK_ITEM_FACTORY_CLASS (GTK_OBJECT (ifactory)->klass);
+ class = GTK_ITEM_FACTORY_GET_CLASS (ifactory);
if (path[0] == '<')
item = g_hash_table_lookup (class->item_ht, (gpointer) path);
g_return_if_fail (GTK_IS_ITEM_FACTORY (ifactory));
g_return_if_fail (path != NULL);
- class = GTK_ITEM_FACTORY_CLASS (GTK_OBJECT (ifactory)->klass);
+ class = GTK_ITEM_FACTORY_GET_CLASS (ifactory);
fpath = g_strconcat (ifactory->path, path, NULL);
item = g_hash_table_lookup (class->item_ht, fpath);
static void gtk_label_get_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
-static void gtk_label_finalize (GtkObject *object);
+static void gtk_label_finalize (GObject *object);
static void gtk_label_size_request (GtkWidget *widget,
GtkRequisition *requisition);
static void gtk_label_style_set (GtkWidget *widget,
if (!label_type)
{
- static const GtkTypeInfo label_info =
+ static const GTypeInfo label_info =
{
- "GtkLabel",
- sizeof (GtkLabel),
sizeof (GtkLabelClass),
- (GtkClassInitFunc) gtk_label_class_init,
- (GtkObjectInitFunc) gtk_label_init,
- /* reserved_1 */ NULL,
- /* reserved_2 */ NULL,
- (GtkClassInitFunc) NULL,
+ NULL, /* base_init */
+ NULL, /* base_finalize */
+ (GClassInitFunc) gtk_label_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GtkLabel),
+ 32, /* n_preallocs */
+ (GInstanceInitFunc) gtk_label_init,
};
-
- label_type = gtk_type_unique (GTK_TYPE_MISC, &label_info);
- gtk_type_set_chunk_alloc (label_type, 32);
+
+ label_type = g_type_register_static (GTK_TYPE_MISC, "GtkLabel", &label_info);
}
return label_type;
static void
gtk_label_class_init (GtkLabelClass *class)
{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
gtk_object_add_arg_type ("GtkLabel::justify", GTK_TYPE_JUSTIFICATION, GTK_ARG_READWRITE, ARG_JUSTIFY);
gtk_object_add_arg_type ("GtkLabel::wrap", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_WRAP);
+ gobject_class->finalize = gtk_label_finalize;
+
object_class->set_arg = gtk_label_set_arg;
object_class->get_arg = gtk_label_get_arg;
- object_class->finalize = gtk_label_finalize;
widget_class->size_request = gtk_label_size_request;
widget_class->style_set = gtk_label_style_set;
}
static void
-gtk_label_finalize (GtkObject *object)
+gtk_label_finalize (GObject *object)
{
GtkLabel *label;
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_LABEL (object));
label = GTK_LABEL (object);
gtk_label_free_words (label);
- GTK_OBJECT_CLASS (parent_class)->finalize (object);
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
static GtkLabelULine*
static void gtk_layout_class_init (GtkLayoutClass *class);
static void gtk_layout_init (GtkLayout *layout);
-static void gtk_layout_finalize (GtkObject *object);
+static void gtk_layout_finalize (GObject *object);
static void gtk_layout_realize (GtkWidget *widget);
static void gtk_layout_unrealize (GtkWidget *widget);
static void gtk_layout_map (GtkWidget *widget);
}
static void
-gtk_layout_finalize (GtkObject *object)
+gtk_layout_finalize (GObject *object)
{
GtkLayout *layout = GTK_LAYOUT (object);
gtk_object_unref (GTK_OBJECT (layout->hadjustment));
gtk_object_unref (GTK_OBJECT (layout->vadjustment));
- GTK_OBJECT_CLASS (parent_class)->finalize (object);
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
void
if (!layout_type)
{
- static const GtkTypeInfo layout_info =
+ static const GTypeInfo layout_info =
{
- "GtkLayout",
- sizeof (GtkLayout),
sizeof (GtkLayoutClass),
- (GtkClassInitFunc) gtk_layout_class_init,
- (GtkObjectInitFunc) gtk_layout_init,
- (GtkArgSetFunc) NULL,
- (GtkArgGetFunc) NULL,
+ NULL, /* base_init */
+ NULL, /* base_finalize */
+ (GClassInitFunc) gtk_layout_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GtkLayout),
+ 16, /* n_preallocs */
+ (GInstanceInitFunc) gtk_layout_init,
};
- layout_type = gtk_type_unique (GTK_TYPE_CONTAINER, &layout_info);
+ layout_type = g_type_register_static (GTK_TYPE_CONTAINER, "GtkLayout", &layout_info);
}
return layout_type;
static void
gtk_layout_class_init (GtkLayoutClass *class)
{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkContainerClass *container_class;
parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
- object_class->finalize = gtk_layout_finalize;
+ gobject_class->finalize = gtk_layout_finalize;
widget_class->realize = gtk_layout_realize;
widget_class->unrealize = gtk_layout_unrealize;
widget_class->set_scroll_adjustments_signal =
gtk_signal_new ("set_scroll_adjustments",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkLayoutClass, set_scroll_adjustments),
gtk_marshal_NONE__POINTER_POINTER,
GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
GtkArg *arg,
guint arg_id);
/** GtkObject Methods **/
-static void gtk_list_shutdown (GtkObject *object);
+static void gtk_list_shutdown (GObject *object);
/** GtkWidget Methods **/
static void gtk_list_size_request (GtkWidget *widget,
static void
gtk_list_class_init (GtkListClass *class)
{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkContainerClass *container_class;
vadjustment_key_id = g_quark_from_static_string (vadjustment_key);
hadjustment_key_id = g_quark_from_static_string (hadjustment_key);
+ gobject_class->shutdown = gtk_list_shutdown;
+
list_signals[SELECTION_CHANGED] =
gtk_signal_new ("selection_changed",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListClass, selection_changed),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
list_signals[SELECT_CHILD] =
gtk_signal_new ("select_child",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListClass, select_child),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1,
list_signals[UNSELECT_CHILD] =
gtk_signal_new ("unselect_child",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListClass, unselect_child),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1,
gtk_object_class_add_signals (object_class, list_signals, LAST_SIGNAL);
- object_class->shutdown = gtk_list_shutdown;
object_class->set_arg = gtk_list_set_arg;
object_class->get_arg = gtk_list_get_arg;
* gtk_list_shutdown
*/
static void
-gtk_list_shutdown (GtkObject *object)
+gtk_list_shutdown (GObject *object)
{
gtk_list_clear_items (GTK_LIST (object), 0, -1);
- GTK_OBJECT_CLASS (parent_class)->shutdown (object);
+
+ G_OBJECT_CLASS (parent_class)->shutdown (object);
}
list_item_signals[TOGGLE_FOCUS_ROW] =
gtk_signal_new ("toggle_focus_row",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, toggle_focus_row),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
list_item_signals[SELECT_ALL] =
gtk_signal_new ("select_all",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, select_all),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
list_item_signals[UNSELECT_ALL] =
gtk_signal_new ("unselect_all",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, unselect_all),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
list_item_signals[UNDO_SELECTION] =
gtk_signal_new ("undo_selection",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, undo_selection),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
list_item_signals[START_SELECTION] =
gtk_signal_new ("start_selection",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, start_selection),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
list_item_signals[END_SELECTION] =
gtk_signal_new ("end_selection",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, end_selection),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
list_item_signals[TOGGLE_ADD_MODE] =
gtk_signal_new ("toggle_add_mode",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, toggle_add_mode),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
list_item_signals[EXTEND_SELECTION] =
gtk_signal_new ("extend_selection",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, extend_selection),
gtk_marshal_NONE__ENUM_FLOAT_BOOL,
GTK_TYPE_NONE, 3,
list_item_signals[SCROLL_VERTICAL] =
gtk_signal_new ("scroll_vertical",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, scroll_vertical),
gtk_marshal_NONE__ENUM_FLOAT,
GTK_TYPE_NONE, 2, GTK_TYPE_ENUM, GTK_TYPE_FLOAT);
list_item_signals[SCROLL_HORIZONTAL] =
gtk_signal_new ("scroll_horizontal",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, scroll_horizontal),
gtk_marshal_NONE__ENUM_FLOAT,
GTK_TYPE_NONE, 2, GTK_TYPE_ENUM, GTK_TYPE_FLOAT);
gtk_init_check (int *argc,
char ***argv)
{
- extern void gtk_object_post_arg_parsing_init (void);
GSList *gtk_modules = NULL;
GSList *slist;
gchar *env_string = NULL;
gtk_colormap = gdk_colormap_get_system ();
gtk_type_init ();
- gtk_object_post_arg_parsing_init ();
gtk_signal_init ();
gtk_rc_init ();
INT:POINTER,CHAR,CHAR
NONE:BOOL
NONE:BOXED
-NONE:C_CALLBACK
-NONE:C_CALLBACK,C_CALLBACK
NONE:ENUM
NONE:ENUM,FLOAT
NONE:ENUM,FLOAT,BOOL
INT:POINTER,CHAR,CHAR
NONE:BOOL
NONE:BOXED
-NONE:C_CALLBACK
-NONE:C_CALLBACK,C_CALLBACK
NONE:ENUM
NONE:ENUM,FLOAT
NONE:ENUM,FLOAT,BOOL
#include "gtkwindow.h"
-#define MENU_ITEM_CLASS(w) GTK_MENU_ITEM_CLASS (GTK_OBJECT (w)->klass)
+#define MENU_ITEM_CLASS(w) GTK_MENU_ITEM_GET_CLASS (w)
#define MENU_NEEDS_RESIZE(m) GTK_MENU_SHELL (m)->menu_flag
typedef struct _GtkMenuAttachData GtkMenuAttachData;
menu->position_func = NULL;
menu->position_func_data = NULL;
- menu->toplevel = gtk_window_new (GTK_WINDOW_POPUP);
- gtk_signal_connect (GTK_OBJECT (menu->toplevel),
- "event",
- GTK_SIGNAL_FUNC (gtk_menu_window_event),
- GTK_OBJECT (menu));
+ menu->toplevel = gtk_widget_new (GTK_TYPE_WINDOW,
+ "type", GTK_WINDOW_POPUP,
+ "signal::event", gtk_menu_window_event, menu,
+ "signal::destroy", gtk_widget_destroyed, &menu->toplevel,
+ "child", menu,
+ NULL);
gtk_window_set_policy (GTK_WINDOW (menu->toplevel),
FALSE, FALSE, TRUE);
- gtk_container_add (GTK_CONTAINER (menu->toplevel), GTK_WIDGET (menu));
-
/* Refloat the menu, so that reference counting for the menu isn't
* affected by it being a child of the toplevel
*/
GTK_WIDGET_SET_FLAGS (menu, GTK_FLOATING);
+ menu->needs_destruction_ref_count = TRUE;
menu->tearoff_window = NULL;
menu->torn_off = FALSE;
}
static void
-gtk_menu_destroy (GtkObject *object)
+gtk_menu_destroy (GtkObject *object)
{
GtkMenu *menu;
GtkMenuAttachData *data;
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_MENU (object));
menu = GTK_MENU (object);
- gtk_object_ref (object);
-
data = gtk_object_get_data (object, attach_data_key);
if (data)
gtk_menu_detach (menu);
}
/* Add back the reference count for being a child */
- gtk_object_ref (object);
+ if (menu->needs_destruction_ref_count)
+ {
+ menu->needs_destruction_ref_count = FALSE;
+ gtk_object_ref (object);
+ }
- gtk_widget_destroy (menu->toplevel);
+ if (menu->toplevel)
+ gtk_widget_destroy (menu->toplevel);
if (menu->tearoff_window)
gtk_widget_destroy (menu->tearoff_window);
- if (GTK_OBJECT_CLASS (parent_class)->destroy)
- (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
-
- gtk_object_unref (object);
+ GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
}
GtkWidget*
-gtk_menu_get_attach_widget (GtkMenu *menu)
+gtk_menu_get_attach_widget (GtkMenu *menu)
{
GtkMenuAttachData *data;
}
void
-gtk_menu_detach (GtkMenu *menu)
+gtk_menu_detach (GtkMenu *menu)
{
GtkMenuAttachData *data;
GtkWidget *attach_widget;
gchar *title;
- menu->tearoff_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ menu->tearoff_window = gtk_widget_new (GTK_TYPE_WINDOW,
+ "type", GTK_WINDOW_TOPLEVEL,
+ "signal::destroy", gtk_widget_destroyed, &menu->tearoff_window,
+ NULL);
gtk_widget_set_app_paintable (menu->tearoff_window, TRUE);
gtk_signal_connect (GTK_OBJECT (menu->tearoff_window),
"event",
GtkWidget *toplevel;
GtkWidget *tearoff_window;
+ guint needs_destruction_ref_count : 1;
guint torn_off : 1;
};
if (!menu_item_type)
{
- static const GtkTypeInfo menu_item_info =
+ static const GTypeInfo menu_item_info =
{
- "GtkMenuItem",
- sizeof (GtkMenuItem),
sizeof (GtkMenuItemClass),
- (GtkClassInitFunc) gtk_menu_item_class_init,
- (GtkObjectInitFunc) gtk_menu_item_init,
- /* reserved_1 */ NULL,
- /* reserved_2 */ NULL,
- (GtkClassInitFunc) NULL,
+ NULL, /* base_init */
+ NULL, /* base_finalize */
+ (GClassInitFunc) gtk_menu_item_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GtkMenuItem),
+ 16, /* n_preallocs */
+ (GInstanceInitFunc) gtk_menu_item_init,
};
- menu_item_type = gtk_type_unique (gtk_item_get_type (), &menu_item_info);
- gtk_type_set_chunk_alloc (menu_item_type, 16);
+ menu_item_type = g_type_register_static (GTK_TYPE_ITEM, "GtkMenuItem", &menu_item_info);
}
return menu_item_type;
menu_item_signals[ACTIVATE] =
gtk_signal_new ("activate",
GTK_RUN_FIRST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkMenuItemClass, activate),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
menu_item_signals[ACTIVATE_ITEM] =
gtk_signal_new ("activate_item",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkMenuItemClass, activate_item),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
#define MENU_SHELL_TIMEOUT 500
-#define MENU_SHELL_CLASS(w) GTK_MENU_SHELL_CLASS (GTK_OBJECT (w)->klass)
enum {
menu_shell_signals[DEACTIVATE] =
gtk_signal_new ("deactivate",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkMenuShellClass, deactivate),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
menu_shell_signals[SELECTION_DONE] =
gtk_signal_new ("selection-done",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkMenuShellClass, selection_done),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
menu_shell_signals[MOVE_CURRENT] =
gtk_signal_new ("move_current",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkMenuShellClass, move_current),
gtk_marshal_NONE__ENUM,
GTK_TYPE_NONE, 1,
menu_shell_signals[ACTIVATE_CURRENT] =
gtk_signal_new ("activate_current",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkMenuShellClass, activate_current),
gtk_marshal_NONE__BOOL,
GTK_TYPE_NONE, 1,
menu_shell_signals[CANCEL] =
gtk_signal_new ("cancel",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkMenuShellClass, cancel),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
menu_shell->active_menu_item = menu_item;
gtk_menu_item_set_placement (GTK_MENU_ITEM (menu_shell->active_menu_item),
- MENU_SHELL_CLASS (menu_shell)->submenu_placement);
+ GTK_MENU_SHELL_GET_CLASS (menu_shell)->submenu_placement);
gtk_menu_item_select (GTK_MENU_ITEM (menu_shell->active_menu_item));
/* This allows the bizarre radio buttons-with-submenus-display-history
g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
if (!deactivate)
- deactivate = GTK_MENU_ITEM_CLASS (GTK_OBJECT (menu_item)->klass)->hide_on_activate;
+ deactivate = GTK_MENU_ITEM_GET_CLASS (menu_item)->hide_on_activate;
gtk_widget_ref (GTK_WIDGET (menu_shell));
case GTK_MENU_DIR_PARENT:
if (parent_menu_shell)
{
- if (GTK_MENU_SHELL_CLASS (GTK_OBJECT (parent_menu_shell)->klass)->submenu_placement ==
- GTK_MENU_SHELL_CLASS (GTK_OBJECT (menu_shell)->klass)->submenu_placement)
+ if (GTK_MENU_SHELL_GET_CLASS (parent_menu_shell)->submenu_placement ==
+ GTK_MENU_SHELL_GET_CLASS (menu_shell)->submenu_placement)
gtk_menu_shell_deselect (menu_shell);
else
{
{
/* Try to find a menu running the opposite direction */
while (parent_menu_shell &&
- (GTK_MENU_SHELL_CLASS (GTK_OBJECT (parent_menu_shell)->klass)->submenu_placement ==
- GTK_MENU_SHELL_CLASS (GTK_OBJECT (menu_shell)->klass)->submenu_placement))
+ (GTK_MENU_SHELL_GET_CLASS (parent_menu_shell)->submenu_placement ==
+ GTK_MENU_SHELL_GET_CLASS (menu_shell)->submenu_placement))
parent_menu_shell = GTK_MENU_SHELL (parent_menu_shell->parent_menu_shell);
if (parent_menu_shell)
notebook_signals[SWITCH_PAGE] =
gtk_signal_new ("switch_page",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkNotebookClass, switch_page),
gtk_marshal_NONE__POINTER_UINT,
GTK_TYPE_NONE, 2,
};
-void gtk_object_init_type (void);
-static void gtk_object_base_class_init (GtkObjectClass *klass);
-static void gtk_object_class_init (GtkObjectClass *klass);
-static void gtk_object_init (GtkObject *object,
+extern void gtk_object_init_type (void); /* for gtktypeutils.h */
+static void gtk_object_base_class_init (GtkObjectClass *class);
+static void gtk_object_base_class_finalize (GtkObjectClass *class);
+static void gtk_object_class_init (GtkObjectClass *klass);
+static void gtk_object_init (GtkObject *object,
GtkObjectClass *klass);
-static void gtk_object_set_arg (GtkObject *object,
+static void gtk_object_set_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
-static void gtk_object_get_arg (GtkObject *object,
+static void gtk_object_get_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
-static void gtk_object_shutdown (GtkObject *object);
-static void gtk_object_real_destroy (GtkObject *object);
-static void gtk_object_finalize (GtkObject *object);
-static void gtk_object_notify_weaks (GtkObject *object);
-
-static guint object_signals[LAST_SIGNAL] = { 0 };
+static void gtk_object_shutdown (GObject *object);
+static void gtk_object_real_destroy (GtkObject *object);
+static void gtk_object_finalize (GObject *object);
+static void gtk_object_notify_weaks (GtkObject *object);
+static gpointer parent_class = NULL;
+static guint object_signals[LAST_SIGNAL] = { 0 };
static GHashTable *object_arg_info_ht = NULL;
+static GQuark quark_user_data = 0;
+static GQuark quark_weakrefs = 0;
+static GQuark quark_carg_history = 0;
-static GQuark quark_user_data = 0;
-static GQuark quark_weakrefs = 0;
-static GQuark quark_carg_history = 0;
-
-
-#ifdef G_ENABLE_DEBUG
-static guint obj_count = 0;
-static GHashTable *living_objs_ht = NULL;
-static void
-gtk_object_debug_foreach (gpointer key, gpointer value, gpointer user_data)
-{
- GtkObject *object;
-
- object = (GtkObject*) value;
- g_message ("[%p] %s\tref_count=%d%s%s",
- object,
- gtk_type_name (GTK_OBJECT_TYPE (object)),
- object->ref_count,
- GTK_OBJECT_FLOATING (object) ? " (floating)" : "",
- GTK_OBJECT_DESTROYED (object) ? " (destroyed)" : "");
-}
-static void
-gtk_object_debug (void)
-{
- if (living_objs_ht)
- g_hash_table_foreach (living_objs_ht, gtk_object_debug_foreach, NULL);
-
- g_message ("living objects count = %d", obj_count);
-}
-#endif /* G_ENABLE_DEBUG */
-
-void
-gtk_object_post_arg_parsing_init (void)
-{
-#ifdef G_ENABLE_DEBUG
- if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
- g_atexit (gtk_object_debug);
-#endif /* G_ENABLE_DEBUG */
-}
/****************************************************
* GtkObject type, class and instance initialization
*
****************************************************/
-void
-gtk_object_init_type (void)
-{
- static const GtkTypeInfo object_info =
- {
- "GtkObject",
- sizeof (GtkObject),
- sizeof (GtkObjectClass),
- (GtkClassInitFunc) gtk_object_class_init,
- (GtkObjectInitFunc) gtk_object_init,
- /* reserved_1 */ NULL,
- /* reserved_2 */ NULL,
- (GtkClassInitFunc) gtk_object_base_class_init,
- };
- GtkType object_type;
-
- object_type = gtk_type_unique (0, &object_info);
- g_assert (object_type == GTK_TYPE_OBJECT);
-}
-
GtkType
gtk_object_get_type (void)
{
- return GTK_TYPE_OBJECT;
+ static GtkType object_type = 0;
+
+ if (!object_type)
+ {
+ static const GTypeInfo object_info =
+ {
+ sizeof (GtkObjectClass),
+ (GBaseInitFunc) gtk_object_base_class_init,
+ (GBaseFinalizeFunc) gtk_object_base_class_finalize,
+ (GClassInitFunc) gtk_object_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GtkObject),
+ 16, /* n_preallocs */
+ (GInstanceInitFunc) gtk_object_init,
+ };
+
+ object_type = g_type_register_static (G_TYPE_OBJECT, "GtkObject", &object_info);
+ }
+
+ return object_type;
}
static void
class->set_arg = NULL;
}
+static void
+gtk_object_base_class_finalize (GtkObjectClass *class)
+{
+ g_free (class->signals);
+ g_return_if_fail (class->construct_args == NULL);
+}
+
static void
gtk_object_class_init (GtkObjectClass *class)
{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+
+ parent_class = g_type_class_ref (G_TYPE_OBJECT);
+
+ gobject_class->shutdown = gtk_object_shutdown;
+ gobject_class->finalize = gtk_object_finalize;
+
+ class->get_arg = gtk_object_get_arg;
+ class->set_arg = gtk_object_set_arg;
+ class->destroy = gtk_object_real_destroy;
+
quark_carg_history = g_quark_from_static_string ("gtk-construct-arg-history");
gtk_object_add_arg_type ("GtkObject::user_data",
object_signals[DESTROY] =
gtk_signal_new ("destroy",
GTK_RUN_LAST | GTK_RUN_NO_HOOKS,
- class->type,
+ GTK_CLASS_TYPE (class),
GTK_SIGNAL_OFFSET (GtkObjectClass, destroy),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
gtk_object_class_add_signals (class, object_signals, LAST_SIGNAL);
-
- class->get_arg = gtk_object_get_arg;
- class->set_arg = gtk_object_set_arg;
- class->shutdown = gtk_object_shutdown;
- class->destroy = gtk_object_real_destroy;
- class->finalize = gtk_object_finalize;
}
static void
do
{
needs_construction |= klass->construct_args != NULL;
- klass = gtk_type_parent_class (klass->type);
+ klass = g_type_class_peek_parent (klass);
}
while (klass && !needs_construction);
if (!needs_construction)
GTK_OBJECT_FLAGS (object) |= GTK_CONSTRUCTED;
-
- object->ref_count = 1;
- g_datalist_init (&object->object_data);
-
-#ifdef G_ENABLE_DEBUG
- if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
- {
- obj_count++;
-
- if (!living_objs_ht)
- living_objs_ht = g_hash_table_new (g_direct_hash, NULL);
-
- g_hash_table_insert (living_objs_ht, object, object);
- }
-#endif /* G_ENABLE_DEBUG */
}
/********************************************
if (!GTK_OBJECT_DESTROYED (object))
{
- /* we will hold a reference on the object in this place, so
- * to ease all classes shutdown and destroy implementations.
- * i.e. they don't have to bother about referencing at all.
+ /* need to hold a reference count around all class method
+ * invocations. we guard against reinvocations during
+ * destruction with the GTK_DESTROYED flag.
*/
gtk_object_ref (object);
- object->klass->shutdown (object);
+ GTK_OBJECT_SET_FLAGS (object, GTK_DESTROYED);
+ G_OBJECT_GET_CLASS (object)->shutdown (G_OBJECT (object));
+ GTK_OBJECT_UNSET_FLAGS (object, GTK_DESTROYED);
gtk_object_unref (object);
}
}
static void
-gtk_object_shutdown (GtkObject *object)
+gtk_object_shutdown (GObject *gobject)
{
- GTK_OBJECT_SET_FLAGS (object, GTK_DESTROYED);
+ GtkObject *object = GTK_OBJECT (gobject);
+
gtk_signal_emit (object, object_signals[DESTROY]);
+
+ G_OBJECT_CLASS (parent_class)->shutdown (gobject);
}
static void
}
static void
-gtk_object_finalize (GtkObject *object)
+gtk_object_finalize (GObject *gobject)
{
- gtk_object_notify_weaks (object);
+ GtkObject *object = GTK_OBJECT (gobject);
- g_datalist_clear (&object->object_data);
+ gtk_object_notify_weaks (object);
- gtk_type_free (GTK_OBJECT_TYPE (object), object);
+ G_OBJECT_CLASS (parent_class)->finalize (gobject);
}
/*****************************************
signal_id = gtk_signal_newv (name,
signal_flags,
- class->type,
+ GTK_CLASS_TYPE (class),
0,
marshaller,
return_val,
signal_id = gtk_signal_newv (name,
signal_flags,
- class->type,
+ GTK_CLASS_TYPE (class),
0,
marshaller,
return_val,
GSList *info_list = NULL;
gchar *error;
- g_return_val_if_fail (GTK_FUNDAMENTAL_TYPE (object_type) == GTK_TYPE_OBJECT, NULL);
+ g_return_val_if_fail (GTK_TYPE_IS_OBJECT (object_type), NULL);
object = gtk_type_new (object_type);
GtkObject *object;
GtkArg *max_args;
- g_return_val_if_fail (GTK_FUNDAMENTAL_TYPE (object_type) == GTK_TYPE_OBJECT, NULL);
+ g_return_val_if_fail (GTK_TYPE_IS_OBJECT (object_type), NULL);
if (n_args)
g_return_val_if_fail (args != NULL, NULL);
if (!GTK_OBJECT_CONSTRUCTED (object))
{
- for (slist = object->klass->construct_args;
+ for (slist = GTK_OBJECT_GET_CLASS (object)->construct_args;
slist && !GTK_OBJECT_CONSTRUCTED (object);
slist = slist->next)
{
/* default application */
arg.type = info->type;
arg.name = info->name;
- switch (gtk_type_get_varargs_type (arg.type))
+ switch (G_TYPE_FUNDAMENTAL (arg.type))
{
case GTK_TYPE_FLOAT:
GTK_VALUE_FLOAT (arg) = 0.0;
case GTK_TYPE_BOXED:
case GTK_TYPE_STRING:
case GTK_TYPE_POINTER:
- case GTK_TYPE_OBJECT:
+ case G_TYPE_OBJECT:
GTK_VALUE_POINTER (arg) = NULL;
break;
default:
{
g_return_val_if_fail (n_args != NULL, NULL);
*n_args = 0;
- g_return_val_if_fail (GTK_FUNDAMENTAL_TYPE (class_type) == GTK_TYPE_OBJECT, NULL);
+ g_return_val_if_fail (GTK_TYPE_IS_OBJECT (class_type), NULL);
return gtk_args_query (class_type, object_arg_info_ht, arg_flags, n_args);
}
GQuark data_id,
gpointer data)
{
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
- g_datalist_id_set_data (&object->object_data, data_id, data);
+ g_datalist_id_set_data (&G_OBJECT (object)->qdata, data_id, data);
}
void
const gchar *key,
gpointer data)
{
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
g_return_if_fail (key != NULL);
- g_datalist_set_data (&object->object_data, key, data);
+ g_datalist_set_data (&G_OBJECT (object)->qdata, key, data);
}
void
gpointer data,
GtkDestroyNotify destroy)
{
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
- g_datalist_id_set_data_full (&object->object_data, data_id, data, destroy);
+ g_datalist_id_set_data_full (&G_OBJECT (object)->qdata, data_id, data, destroy);
}
void
gpointer data,
GtkDestroyNotify destroy)
{
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
g_return_if_fail (key != NULL);
- g_datalist_set_data_full (&object->object_data, key, data, destroy);
+ g_datalist_set_data_full (&G_OBJECT (object)->qdata, key, data, destroy);
}
gpointer
gtk_object_get_data_by_id (GtkObject *object,
GQuark data_id)
{
- g_return_val_if_fail (object != NULL, NULL);
g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
- return g_datalist_id_get_data (&object->object_data, data_id);
+ return g_datalist_id_get_data (&G_OBJECT (object)->qdata, data_id);
}
gpointer
gtk_object_get_data (GtkObject *object,
const gchar *key)
{
- g_return_val_if_fail (object != NULL, NULL);
g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
g_return_val_if_fail (key != NULL, NULL);
- return g_datalist_get_data (&object->object_data, key);
+ return g_datalist_get_data (&G_OBJECT (object)->qdata, key);
}
void
gtk_object_remove_data_by_id (GtkObject *object,
GQuark data_id)
{
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
- g_datalist_id_remove_data (&object->object_data, data_id);
+ g_datalist_id_remove_data (&G_OBJECT (object)->qdata, data_id);
}
void
gtk_object_remove_data (GtkObject *object,
const gchar *key)
{
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
g_return_if_fail (key != NULL);
- g_datalist_remove_data (&object->object_data, key);
+ g_datalist_remove_data (&G_OBJECT (object)->qdata, key);
}
void
gtk_object_remove_no_notify_by_id (GtkObject *object,
GQuark key_id)
{
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
- g_datalist_id_remove_no_notify (&object->object_data, key_id);
+ g_datalist_id_remove_no_notify (&G_OBJECT (object)->qdata, key_id);
}
void
gtk_object_remove_no_notify (GtkObject *object,
const gchar *key)
{
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
g_return_if_fail (key != NULL);
- g_datalist_remove_no_notify (&object->object_data, key);
+ g_datalist_remove_no_notify (&G_OBJECT (object)->qdata, key);
}
void
gtk_object_set_user_data (GtkObject *object,
gpointer data)
{
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
if (!quark_user_data)
quark_user_data = g_quark_from_static_string ("user_data");
- g_datalist_id_set_data (&object->object_data, quark_user_data, data);
+ g_datalist_id_set_data (&G_OBJECT (object)->qdata, quark_user_data, data);
}
gpointer
gtk_object_get_user_data (GtkObject *object)
{
- g_return_val_if_fail (object != NULL, NULL);
g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
- return g_datalist_id_get_data (&object->object_data, quark_user_data);
+ return g_datalist_id_get_data (&G_OBJECT (object)->qdata, quark_user_data);
}
-/*******************************************
- * GtkObject referencing and unreferencing
- *
- *******************************************/
-
-#undef gtk_object_ref
-#undef gtk_object_unref
-
-void
+GtkObject*
gtk_object_ref (GtkObject *object)
{
- g_return_if_fail (object != NULL);
- g_return_if_fail (GTK_IS_OBJECT (object));
- g_return_if_fail (object->ref_count > 0);
+ g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
- object->ref_count += 1;
+ return (GtkObject*) g_object_ref ((GObject*) object);
}
void
gtk_object_unref (GtkObject *object)
{
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
- g_return_if_fail (object->ref_count > 0);
-
- if (object->ref_count == 1)
- {
- gtk_object_destroy (object);
-
- g_return_if_fail (object->ref_count > 0);
- }
-
- object->ref_count -= 1;
-
- if (object->ref_count == 0)
- {
-#ifdef G_ENABLE_DEBUG
- if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
- {
- g_assert (g_hash_table_lookup (living_objs_ht, object) == object);
- g_hash_table_remove (living_objs_ht, object);
- obj_count--;
- }
-#endif /* G_ENABLE_DEBUG */
- object->klass->finalize (object);
- }
-}
-
-static GtkObject *gtk_trace_object = NULL;
-void
-gtk_trace_referencing (GtkObject *object,
- const gchar *func,
- guint dummy,
- guint line,
- gboolean do_ref)
-{
- if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
- {
- gboolean exists = TRUE;
- g_return_if_fail (object != NULL);
- g_return_if_fail (GTK_IS_OBJECT (object));
-
-#ifdef G_ENABLE_DEBUG
- exists = g_hash_table_lookup (living_objs_ht, object) != NULL;
-#endif /* G_ENABLE_DEBUG */
-
- if (exists &&
- (object == gtk_trace_object ||
- gtk_trace_object == (void*)42))
- fprintf (stdout, "trace: object_%s: (%s:%p)->ref_count=%d %s (%s:%d)\n",
- do_ref ? "ref" : "unref",
- gtk_type_name (GTK_OBJECT_TYPE (object)),
- object,
- object->ref_count,
- do_ref ? "+ 1" : "- 1",
- func,
- line);
- else if (!exists)
- fprintf (stdout, "trace: object_%s(%p): no such object! (%s:%d)\n",
- do_ref ? "ref" : "unref",
- object,
- func,
- line);
- }
-
- if (do_ref)
- gtk_object_ref (object);
- else
- gtk_object_unref (object);
+ g_object_unref ((GObject*) object);
}
#endif /* __cplusplus */
-
-/* Macro for casting a pointer to a GtkObject or GtkObjectClass pointer.
- * The second portion of the ?: statments are just in place to offer
- * descriptive warning message.
- */
-#define GTK_OBJECT(object) ( \
- GTK_IS_OBJECT (object) ? \
- (GtkObject*) (object) : \
- (GtkObject*) gtk_type_check_object_cast ((GtkTypeObject*) (object), GTK_TYPE_OBJECT) \
-)
-#define GTK_OBJECT_CLASS(klass) ( \
- GTK_IS_OBJECT_CLASS (klass) ? \
- (GtkObjectClass*) (klass) : \
- (GtkObjectClass*) gtk_type_check_class_cast ((GtkTypeClass*) (klass), GTK_TYPE_OBJECT) \
-)
-
-/* Macro for testing whether `object' and `klass' are of type GTK_TYPE_OBJECT.
+/* macros for casting a pointer to a GtkObject or GtkObjectClass pointer,
+ * and to test whether `object' and `klass' are of type GTK_TYPE_OBJECT.
+ * these are the standard macros for all GtkObject-derived classes.
*/
-#define GTK_IS_OBJECT(object) ( \
- (object) != NULL && \
- GTK_IS_OBJECT_CLASS (((GtkObject*) (object))->klass) \
-)
-#define GTK_IS_OBJECT_CLASS(klass) ( \
- (klass) != NULL && \
- GTK_FUNDAMENTAL_TYPE (((GtkObjectClass*) (klass))->type) == GTK_TYPE_OBJECT \
-)
+#define GTK_TYPE_OBJECT (gtk_object_get_type ())
+#define GTK_OBJECT(object) (GTK_CHECK_CAST ((object), GTK_TYPE_OBJECT, GtkObject))
+#define GTK_OBJECT_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_OBJECT, GtkObjectClass))
+#define GTK_IS_OBJECT(object) (GTK_CHECK_TYPE ((object), GTK_TYPE_OBJECT))
+#define GTK_IS_OBJECT_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_OBJECT))
+#define GTK_OBJECT_GET_CLASS(object) (GTK_CHECK_GET_CLASS ((object), GTK_TYPE_OBJECT, GtkObjectClass))
/* Macros for extracting various fields from GtkObject and GtkObjectClass.
*/
-#define GTK_OBJECT_TYPE(obj) (GTK_OBJECT (obj)->klass->type)
-#define GTK_OBJECT_SIGNALS(obj) (GTK_OBJECT (obj)->klass->signals)
-#define GTK_OBJECT_NSIGNALS(obj) (GTK_OBJECT (obj)->klass->nsignals)
+#define GTK_OBJECT_TYPE(object) (G_TYPE_FROM_INSTANCE (object))
+#define GTK_OBJECT_TYPE_NAME(object) (g_type_name (GTK_OBJECT_TYPE (object)))
/* GtkObject only uses the first 4 bits of the flags field.
* Derived objects may use the remaining bits. Though this
*/
struct _GtkObject
{
- /* GtkTypeObject related fields: */
- GtkObjectClass *klass;
-
+ GObject parent_instance;
/* 32 bits of flags. GtkObject only uses 4 of these bits and
* GtkWidget uses the rest. This is done because structs are
* used in GtkWidget much space would be wasted.
*/
guint32 flags;
-
- /* reference count.
- * refer to the file docs/refcounting.txt on this issue.
- */
- guint ref_count;
-
- /* A list of keyed data pointers, used for e.g. the list of signal
- * handlers or an object's user_data.
- */
- GData *object_data;
};
/* The GtkObjectClass is the base of the Gtk+ objects classes hierarchy,
*/
struct _GtkObjectClass
{
- /* GtkTypeClass fields: */
- GtkType type;
-
+ GObjectClass parent_class;
/* The signals this object class handles. "signals" is an
* array of signal ID's.
GtkArg *arg,
guint arg_id);
- /* The functions that will end an objects life time. In one way ore
+ /* The function that will end an objects life time. In one way ore
* another all three of them are defined for all objects. If an
* object class overrides one of the methods in order to perform class
* specific destruction then it must still invoke its superclass'
* own cleanup. (See the destroy function for GtkWidget for
* an example of how to do this).
*/
- void (* shutdown) (GtkObject *object);
void (* destroy) (GtkObject *object);
-
- void (* finalize) (GtkObject *object);
};
GtkObject* gtk_object_newv (GtkType object_type,
guint n_args,
GtkArg *args);
+GtkObject* gtk_object_ref (GtkObject *object);
+void gtk_object_unref (GtkObject *object);
void gtk_object_default_construct (GtkObject *object);
void gtk_object_constructed (GtkObject *object);
void gtk_object_sink (GtkObject *object);
-void gtk_object_ref (GtkObject *object);
-void gtk_object_unref (GtkObject *object);
void gtk_object_weakref (GtkObject *object,
GtkDestroyNotify notify,
gpointer data);
gchar* gtk_object_arg_get_info (GtkType object_type,
const gchar *arg_name,
GtkArgInfo **info_p);
-void gtk_trace_referencing (GtkObject *object,
- const gchar *func,
- guint dummy,
- guint line,
- gboolean do_ref);
-#if G_ENABLE_DEBUG
-# define gtk_object_ref(o) G_STMT_START{gtk_trace_referencing((o),G_GNUC_PRETTY_FUNCTION,0,__LINE__,1);}G_STMT_END
-# define gtk_object_unref(o) G_STMT_START{gtk_trace_referencing((o),G_GNUC_PRETTY_FUNCTION,0,__LINE__,0);}G_STMT_END
-#endif /* G_ENABLE_DEBUG */
-
static void gtk_pixmap_init (GtkPixmap *pixmap);
static gint gtk_pixmap_expose (GtkWidget *widget,
GdkEventExpose *event);
-static void gtk_pixmap_finalize (GtkObject *object);
+static void gtk_pixmap_finalize (GObject *object);
static void build_insensitive_pixmap (GtkPixmap *gtkpixmap);
static GtkWidgetClass *parent_class;
static void
gtk_pixmap_class_init (GtkPixmapClass *class)
{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
widget_class = (GtkWidgetClass*) class;
parent_class = gtk_type_class (gtk_widget_get_type ());
- object_class->finalize = gtk_pixmap_finalize;
+ gobject_class->finalize = gtk_pixmap_finalize;
+
widget_class->expose_event = gtk_pixmap_expose;
}
}
static void
-gtk_pixmap_finalize (GtkObject *object)
+gtk_pixmap_finalize (GObject *object)
{
gtk_pixmap_set (GTK_PIXMAP (object), NULL, NULL);
- (* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
+
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
void
if (!plug_type)
{
- static const GtkTypeInfo plug_info =
+ static const GTypeInfo plug_info =
{
- "GtkPlug",
- sizeof (GtkPlug),
sizeof (GtkPlugClass),
- (GtkClassInitFunc) gtk_plug_class_init,
- (GtkObjectInitFunc) gtk_plug_init,
- (GtkArgSetFunc) NULL,
- (GtkArgGetFunc) NULL
+ NULL, /* base_init */
+ NULL, /* base_finalize */
+ (GClassInitFunc) gtk_plug_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GtkPlug),
+ 16, /* n_preallocs */
+ (GInstanceInitFunc) gtk_plug_init,
};
- plug_type = gtk_type_unique (GTK_TYPE_WINDOW, &plug_info);
+ plug_type = g_type_register_static (GTK_TYPE_WINDOW, "GtkPlug", &plug_info);
}
return plug_type;
static void gtk_preview_get_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
-static void gtk_preview_finalize (GtkObject *object);
+static void gtk_preview_finalize (GObject *object);
static void gtk_preview_realize (GtkWidget *widget);
static void gtk_preview_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
static void
gtk_preview_class_init (GtkPreviewClass *klass)
{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
parent_class = gtk_type_class (GTK_TYPE_WIDGET);
preview_class = klass;
+ gobject_class->finalize = gtk_preview_finalize;
+
object_class->set_arg = gtk_preview_set_arg;
object_class->get_arg = gtk_preview_get_arg;
- object_class->finalize = gtk_preview_finalize;
widget_class->realize = gtk_preview_realize;
widget_class->size_allocate = gtk_preview_size_allocate;
static void
-gtk_preview_finalize (GtkObject *object)
+gtk_preview_finalize (GObject *object)
{
GtkPreview *preview;
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_PREVIEW (object));
preview = GTK_PREVIEW (object);
g_free (preview->buffer);
preview->type = (GtkPreviewType) -1;
- (* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
GtkArg *arg,
guint arg_id);
static void gtk_progress_destroy (GtkObject *object);
-static void gtk_progress_finalize (GtkObject *object);
+static void gtk_progress_finalize (GObject *object);
static void gtk_progress_realize (GtkWidget *widget);
static gint gtk_progress_expose (GtkWidget *widget,
GdkEventExpose *event);
static void
gtk_progress_class_init (GtkProgressClass *class)
{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
widget_class = (GtkWidgetClass *) class;
parent_class = gtk_type_class (GTK_TYPE_WIDGET);
+ gobject_class->finalize = gtk_progress_finalize;
+
+ object_class->set_arg = gtk_progress_set_arg;
+ object_class->get_arg = gtk_progress_get_arg;
+ object_class->destroy = gtk_progress_destroy;
+
+ widget_class->realize = gtk_progress_realize;
+ widget_class->expose_event = gtk_progress_expose;
+ widget_class->size_allocate = gtk_progress_size_allocate;
+
+ /* to be overridden */
+ class->paint = NULL;
+ class->update = NULL;
+ class->act_mode_enter = NULL;
+
gtk_object_add_arg_type ("GtkProgress::activity_mode",
GTK_TYPE_BOOL,
GTK_ARG_READWRITE,
GTK_TYPE_FLOAT,
GTK_ARG_READWRITE,
ARG_TEXT_YALIGN);
-
- object_class->set_arg = gtk_progress_set_arg;
- object_class->get_arg = gtk_progress_get_arg;
- object_class->destroy = gtk_progress_destroy;
- object_class->finalize = gtk_progress_finalize;
-
- widget_class->realize = gtk_progress_realize;
- widget_class->expose_event = gtk_progress_expose;
- widget_class->size_allocate = gtk_progress_size_allocate;
-
- /* to be overridden */
- class->paint = NULL;
- class->update = NULL;
- class->act_mode_enter = NULL;
}
static void
progress = GTK_PROGRESS (object);
if (progress->adjustment)
- gtk_signal_disconnect_by_data (GTK_OBJECT (progress->adjustment),
- progress);
+ {
+ gtk_signal_disconnect_by_data (GTK_OBJECT (progress->adjustment),
+ progress);
+ gtk_object_unref (GTK_OBJECT (progress->adjustment));
+ progress->adjustment = NULL;
+ }
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
static void
-gtk_progress_finalize (GtkObject *object)
+gtk_progress_finalize (GObject *object)
{
GtkProgress *progress;
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_PROGRESS (object));
progress = GTK_PROGRESS (object);
- if (progress->adjustment)
- gtk_object_unref (GTK_OBJECT (GTK_PROGRESS (object)->adjustment));
-
if (progress->offscreen_pixmap)
gdk_pixmap_unref (progress->offscreen_pixmap);
if (progress->format)
g_free (progress->format);
- GTK_OBJECT_CLASS (parent_class)->finalize (object);
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
static gint
widget->allocation.width,
widget->allocation.height,
-1);
- GTK_PROGRESS_CLASS (GTK_OBJECT (progress)->klass)->paint (progress);
+ GTK_PROGRESS_GET_CLASS (progress)->paint (progress);
}
}
gtk_progress_value_changed (GtkAdjustment *adjustment,
GtkProgress *progress)
{
- GTK_PROGRESS_CLASS (GTK_OBJECT (progress)->klass)->update (progress);
+ GTK_PROGRESS_GET_CLASS (progress)->update (progress);
}
static gchar *
g_return_if_fail (min <= max);
g_return_if_fail (value >= min && value <= max);
+ if (!progress->adjustment)
+ gtk_progress_set_adjustment (progress, NULL);
adj = progress->adjustment;
if (fabs (adj->lower - min) > EPSILON || fabs (adj->upper - max) > EPSILON)
g_return_if_fail (GTK_IS_PROGRESS (progress));
g_return_if_fail (percentage >= 0 && percentage <= 1.0);
+ if (!progress->adjustment)
+ gtk_progress_set_adjustment (progress, NULL);
gtk_progress_set_value (progress, progress->adjustment->lower + percentage *
(progress->adjustment->upper - progress->adjustment->lower));
}
g_return_val_if_fail (progress != NULL, 0);
g_return_val_if_fail (GTK_IS_PROGRESS (progress), 0);
- return (progress->adjustment->value - progress->adjustment->lower) /
- (progress->adjustment->upper - progress->adjustment->lower);
+ if (!progress->adjustment)
+ gtk_progress_set_adjustment (progress, NULL);
+
+ return ((progress->adjustment->value - progress->adjustment->lower) /
+ (progress->adjustment->upper - progress->adjustment->lower));
}
gfloat
g_return_val_if_fail (progress != NULL, 0);
g_return_val_if_fail (GTK_IS_PROGRESS (progress), 0);
+ if (!progress->adjustment)
+ gtk_progress_set_adjustment (progress, NULL);
+
if (value >= progress->adjustment->lower &&
value <= progress->adjustment->upper)
return (value - progress->adjustment->lower) /
g_return_if_fail (progress != NULL);
g_return_if_fail (GTK_IS_PROGRESS (progress));
+ if (!progress->adjustment)
+ gtk_progress_set_adjustment (progress, NULL);
+
if (fabs (progress->adjustment->value - value) > EPSILON)
gtk_adjustment_set_value (progress->adjustment, value);
}
g_return_val_if_fail (progress != NULL, 0);
g_return_val_if_fail (GTK_IS_PROGRESS (progress), 0);
- return progress->adjustment->value;
+ return progress->adjustment ? progress->adjustment->value : 0;
}
void
g_return_val_if_fail (progress != NULL, 0);
g_return_val_if_fail (GTK_IS_PROGRESS (progress), 0);
+ if (!progress->adjustment)
+ gtk_progress_set_adjustment (progress, NULL);
+
return gtk_progress_build_string (progress, progress->adjustment->value,
- gtk_progress_get_current_percentage (progress));
+ gtk_progress_get_current_percentage (progress));
}
gchar *
g_return_val_if_fail (progress != NULL, 0);
g_return_val_if_fail (GTK_IS_PROGRESS (progress), 0);
+ if (!progress->adjustment)
+ gtk_progress_set_adjustment (progress, NULL);
+
return gtk_progress_build_string (progress, value,
- gtk_progress_get_percentage_from_value (progress, value));
+ gtk_progress_get_percentage_from_value (progress, value));
}
void
progress->activity_mode = (activity_mode != 0);
if (progress->activity_mode)
- GTK_PROGRESS_CLASS
- (GTK_OBJECT (progress)->klass)->act_mode_enter (progress);
+ GTK_PROGRESS_GET_CLASS (progress)->act_mode_enter (progress);
if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (progress)))
gtk_widget_queue_resize (GTK_WIDGET (progress));
gtk_object_add_arg_type ("GtkProgressBar::adjustment",
GTK_TYPE_ADJUSTMENT,
- GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+ GTK_ARG_READWRITE,
ARG_ADJUSTMENT);
gtk_object_add_arg_type ("GtkProgressBar::orientation",
GTK_TYPE_PROGRESS_BAR_ORIENTATION,
ARG_GROUP
};
-#define CHECK_BUTTON_CLASS(w) GTK_CHECK_BUTTON_CLASS (GTK_OBJECT (w)->klass)
-
static void gtk_radio_button_class_init (GtkRadioButtonClass *klass);
static void gtk_radio_button_init (GtkRadioButton *radio_button);
new_area.width, new_area.height);
}
- x = widget->allocation.x + CHECK_BUTTON_CLASS (widget)->indicator_spacing + GTK_CONTAINER (widget)->border_width;
- y = widget->allocation.y + (widget->allocation.height - CHECK_BUTTON_CLASS (widget)->indicator_size) / 2;
- width = CHECK_BUTTON_CLASS (widget)->indicator_size;
- height = CHECK_BUTTON_CLASS (widget)->indicator_size;
+ x = widget->allocation.x + GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_spacing + GTK_CONTAINER (widget)->border_width;
+ y = widget->allocation.y + (widget->allocation.height - GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size) / 2;
+ width = GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size;
+ height = GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size;
if (GTK_TOGGLE_BUTTON (widget)->active)
shadow_type = GTK_SHADOW_IN;
#define SCROLL_INITIAL_DELAY 100
#define SCROLL_DELAY_LENGTH 300
-#define RANGE_CLASS(w) GTK_RANGE_CLASS (GTK_OBJECT (w)->klass)
+#define RANGE_CLASS(w) GTK_RANGE_GET_CLASS (w)
enum {
ARG_0,
GtkArg *arg,
guint arg_id);
static void gtk_range_destroy (GtkObject *object);
-static void gtk_range_finalize (GtkObject *object);
static void gtk_range_draw (GtkWidget *widget,
GdkRectangle *area);
static void gtk_range_draw_focus (GtkWidget *widget);
parent_class = gtk_type_class (GTK_TYPE_WIDGET);
- gtk_object_add_arg_type ("GtkRange::update_policy",
- GTK_TYPE_UPDATE_TYPE,
- GTK_ARG_READWRITE,
- ARG_UPDATE_POLICY);
-
object_class->set_arg = gtk_range_set_arg;
object_class->get_arg = gtk_range_get_arg;
object_class->destroy = gtk_range_destroy;
- object_class->finalize = gtk_range_finalize;
widget_class->draw = gtk_range_draw;
widget_class->draw_focus = gtk_range_draw_focus;
class->trough_keys = NULL;
class->motion = NULL;
class->timer = gtk_real_range_timer;
+
+ gtk_object_add_arg_type ("GtkRange::update_policy",
+ GTK_TYPE_UPDATE_TYPE,
+ GTK_ARG_READWRITE,
+ ARG_UPDATE_POLICY);
}
static void
g_return_val_if_fail (range != NULL, NULL);
g_return_val_if_fail (GTK_IS_RANGE (range), NULL);
+ if (!range->adjustment)
+ gtk_range_set_adjustment (range, NULL);
+
return range->adjustment;
}
gint slider_x, slider_y;
gint new_pos;
- g_return_if_fail (range != NULL);
g_return_if_fail (GTK_IS_RANGE (range));
+ g_return_if_fail (GTK_WIDGET_REALIZED (range));
range = GTK_RANGE (range);
gint slider_x, slider_y;
gint new_pos;
- g_return_if_fail (range != NULL);
g_return_if_fail (GTK_IS_RANGE (range));
+ g_return_if_fail (GTK_WIDGET_REALIZED (range));
range = GTK_RANGE (range);
range = GTK_RANGE (object);
+ gtk_range_remove_timer (range);
if (range->adjustment)
- gtk_signal_disconnect_by_data (GTK_OBJECT (range->adjustment),
- (gpointer) range);
+ {
+ if (range->adjustment)
+ gtk_signal_disconnect_by_data (GTK_OBJECT (range->adjustment),
+ (gpointer) range);
+ gtk_object_unref (GTK_OBJECT (range->adjustment));
+ range->adjustment = NULL;
+ }
(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
}
-static void
-gtk_range_finalize (GtkObject *object)
-{
- GtkRange *range;
-
- g_return_if_fail (object != NULL);
- g_return_if_fail (GTK_IS_RANGE (object));
-
- range = GTK_RANGE (object);
-
- if (range->adjustment)
- gtk_object_unref (GTK_OBJECT (range->adjustment));
-
- (* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
-}
-
static void
gtk_range_draw (GtkWidget *widget,
GdkRectangle *area)
g_return_if_fail (GTK_IS_RANGE (widget));
g_return_if_fail (area != NULL);
- if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_MAPPED (widget))
+ if (GTK_WIDGET_DRAWABLE (widget))
{
range = GTK_RANGE (widget);
gint trough_part;
gfloat jump_perc;
- g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
{
GtkRange *range;
- g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
{
GtkRange *range;
- g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
range = GTK_RANGE (widget);
- if (GTK_WIDGET_VISIBLE (range)) {
- GtkAdjustment *adj = GTK_RANGE (range)->adjustment;
- gfloat new_value = adj->value + ((event->direction == GDK_SCROLL_UP) ?
- -adj->page_increment / 2:
- adj->page_increment / 2);
- new_value = CLAMP (new_value, adj->lower, adj->upper - adj->page_size);
- gtk_adjustment_set_value (adj, new_value);
- }
+ if (GTK_WIDGET_REALIZED (range))
+ {
+ GtkAdjustment *adj = GTK_RANGE (range)->adjustment;
+ gfloat new_value = adj->value + ((event->direction == GDK_SCROLL_UP) ?
+ -adj->page_increment / 2:
+ adj->page_increment / 2);
+ new_value = CLAMP (new_value, adj->lower, adj->upper - adj->page_size);
+ gtk_adjustment_set_value (adj, new_value);
+ }
return TRUE;
}
GdkModifierType mods;
gint x, y, mask;
- g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
GtkScrollType scroll = GTK_SCROLL_NONE;
GtkTroughType pos = GTK_TROUGH_NONE;
- g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
{
GtkRange *range;
- g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
{
GtkRange *range;
- g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
gtk_range_focus_in (GtkWidget *widget,
GdkEventFocus *event)
{
- g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
gtk_range_focus_out (GtkWidget *widget,
GdkEventFocus *event)
{
- g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
static void
gtk_real_range_draw_trough (GtkRange *range)
{
- g_return_if_fail (range != NULL);
g_return_if_fail (GTK_IS_RANGE (range));
if (range->trough)
{
GtkStateType state_type;
- g_return_if_fail (range != NULL);
g_return_if_fail (GTK_IS_RANGE (range));
if (range->slider)
gfloat new_value;
gint return_val;
- g_return_val_if_fail (range != NULL, FALSE);
g_return_val_if_fail (GTK_IS_RANGE (range), FALSE);
new_value = range->adjustment->value;
static void
gtk_range_add_timer (GtkRange *range)
{
- g_return_if_fail (range != NULL);
g_return_if_fail (GTK_IS_RANGE (range));
if (!range->timer)
static void
gtk_range_remove_timer (GtkRange *range)
{
- g_return_if_fail (range != NULL);
g_return_if_fail (GTK_IS_RANGE (range));
if (range->timer)
g_return_if_fail (ruler != NULL);
g_return_if_fail (GTK_IS_RULER (ruler));
- if (GTK_RULER_CLASS (GTK_OBJECT (ruler)->klass)->draw_ticks)
- (* GTK_RULER_CLASS (GTK_OBJECT (ruler)->klass)->draw_ticks) (ruler);
+ if (GTK_RULER_GET_CLASS (ruler)->draw_ticks)
+ GTK_RULER_GET_CLASS (ruler)->draw_ticks (ruler);
}
void
g_return_if_fail (ruler != NULL);
g_return_if_fail (GTK_IS_RULER (ruler));
- if (GTK_RULER_CLASS (GTK_OBJECT (ruler)->klass)->draw_pos)
- (* GTK_RULER_CLASS (GTK_OBJECT (ruler)->klass)->draw_pos) (ruler);
+ if (GTK_RULER_GET_CLASS (ruler)->draw_pos)
+ GTK_RULER_GET_CLASS (ruler)->draw_pos (ruler);
}
#include "gtkscale.h"
-#define SCALE_CLASS(w) GTK_SCALE_CLASS (GTK_OBJECT (w)->klass)
-
enum {
ARG_0,
ARG_DIGITS,
g_return_if_fail (scale != NULL);
g_return_if_fail (GTK_IS_SCALE (scale));
- if (SCALE_CLASS (scale)->draw_value)
- (* SCALE_CLASS (scale)->draw_value) (scale);
+ if (GTK_SCALE_GET_CLASS (scale)->draw_value)
+ GTK_SCALE_GET_CLASS (scale)->draw_value (scale);
}
* under A) at least correspond to the space taken up by its scrollbars.
*/
-#define SCROLLBAR_SPACING(w) (GTK_SCROLLED_WINDOW_CLASS (GTK_OBJECT (w)->klass)->scrollbar_spacing)
+#define SCROLLBAR_SPACING(w) (GTK_SCROLLED_WINDOW_GET_CLASS (w)->scrollbar_spacing)
#define DEFAULT_SCROLLBAR_SPACING 3
GtkArg *arg,
guint arg_id);
static void gtk_scrolled_window_destroy (GtkObject *object);
-static void gtk_scrolled_window_finalize (GtkObject *object);
+static void gtk_scrolled_window_finalize (GObject *object);
static void gtk_scrolled_window_map (GtkWidget *widget);
static void gtk_scrolled_window_unmap (GtkWidget *widget);
static void gtk_scrolled_window_draw (GtkWidget *widget,
static void
gtk_scrolled_window_class_init (GtkScrolledWindowClass *class)
{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkContainerClass *container_class;
container_class = (GtkContainerClass*) class;
parent_class = gtk_type_class (GTK_TYPE_BIN);
+ gobject_class->finalize = gtk_scrolled_window_finalize;
+
+ object_class->set_arg = gtk_scrolled_window_set_arg;
+ object_class->get_arg = gtk_scrolled_window_get_arg;
+ object_class->destroy = gtk_scrolled_window_destroy;
+
+ widget_class->map = gtk_scrolled_window_map;
+ widget_class->unmap = gtk_scrolled_window_unmap;
+ widget_class->draw = gtk_scrolled_window_draw;
+ widget_class->size_request = gtk_scrolled_window_size_request;
+ widget_class->size_allocate = gtk_scrolled_window_size_allocate;
+ widget_class->scroll_event = gtk_scrolled_window_scroll_event;
+
+ container_class->add = gtk_scrolled_window_add;
+ container_class->remove = gtk_scrolled_window_remove;
+ container_class->forall = gtk_scrolled_window_forall;
+
+ class->scrollbar_spacing = DEFAULT_SCROLLBAR_SPACING;
+
gtk_object_add_arg_type ("GtkScrolledWindow::hadjustment",
GTK_TYPE_ADJUSTMENT,
GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
GTK_TYPE_CORNER_TYPE,
GTK_ARG_READWRITE,
ARG_WINDOW_PLACEMENT);
-
- object_class->set_arg = gtk_scrolled_window_set_arg;
- object_class->get_arg = gtk_scrolled_window_get_arg;
- object_class->destroy = gtk_scrolled_window_destroy;
- object_class->finalize = gtk_scrolled_window_finalize;
-
- widget_class->map = gtk_scrolled_window_map;
- widget_class->unmap = gtk_scrolled_window_unmap;
- widget_class->draw = gtk_scrolled_window_draw;
- widget_class->size_request = gtk_scrolled_window_size_request;
- widget_class->size_allocate = gtk_scrolled_window_size_allocate;
- widget_class->scroll_event = gtk_scrolled_window_scroll_event;
-
- container_class->add = gtk_scrolled_window_add;
- container_class->remove = gtk_scrolled_window_remove;
- container_class->forall = gtk_scrolled_window_forall;
-
- class->scrollbar_spacing = DEFAULT_SCROLLBAR_SPACING;
}
static void
}
static void
-gtk_scrolled_window_finalize (GtkObject *object)
+gtk_scrolled_window_finalize (GObject *object)
{
- GtkScrolledWindow *scrolled_window;
-
- scrolled_window = GTK_SCROLLED_WINDOW (object);
+ GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (object);
gtk_widget_unref (scrolled_window->hscrollbar);
gtk_widget_unref (scrolled_window->vscrollbar);
- GTK_OBJECT_CLASS (parent_class)->finalize (object);
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gpointer class = NULL;
g_return_val_if_fail (name != NULL, 0);
- g_return_val_if_fail (gtk_type_is_a (object_type, GTK_TYPE_OBJECT), 0);
+ g_return_val_if_fail (GTK_TYPE_IS_OBJECT (object_type), 0);
relookup:
*/
signal = *LOOKUP_SIGNAL_ID (signal_id);
if (signal.function_offset)
- signal_func = G_STRUCT_MEMBER (GtkSignalFunc, object->klass, signal.function_offset);
+ signal_func = G_STRUCT_MEMBER (GtkSignalFunc, ((GTypeInstance*) object)->g_class, signal.function_offset);
else
signal_func = NULL;
gint found_it;
GtkSignal *signal;
- g_return_val_if_fail (object != NULL, 0);
- g_return_val_if_fail (object->klass != NULL, 0);
+ g_return_val_if_fail (GTK_IS_OBJECT (object), 0);
signal = LOOKUP_SIGNAL_ID (signal_id);
* return correct signal ids per class-branch.
*/
found_it = FALSE;
- class = object->klass;
+ class = GTK_OBJECT_GET_CLASS (object);
while (class)
{
GtkType parent;
break;
}
- parent = gtk_type_parent (class->type);
- if (parent)
- class = gtk_type_class (parent);
+ parent = g_type_parent (GTK_CLASS_TYPE (class));
+ if (GTK_TYPE_IS_OBJECT (parent))
+ class = g_type_class_peek (parent);
else
class = NULL;
}
{
g_warning ("gtk_signal_connect_by_type(): could not find signal id (%u) in the `%s' class ancestry",
signal_id,
- gtk_type_name (object->klass->type));
+ GTK_OBJECT_TYPE_NAME (object));
return 0;
}
return_type = GTK_FUNDAMENTAL_TYPE (return_type);
if (return_type != GTK_TYPE_NONE)
{
- if ((return_type >= GTK_TYPE_FLAT_FIRST &&
- return_type <= GTK_TYPE_FLAT_LAST) ||
- (return_type == GTK_TYPE_OBJECT))
+ if (return_type != 0) // FIXME: check for IS_PARAM
{
GTK_VALUE_POINTER (*params) = va_arg (var_args, gpointer);
if (!socket_type)
{
- static const GtkTypeInfo socket_info =
+ static const GTypeInfo socket_info =
{
- "GtkSocket",
- sizeof (GtkSocket),
sizeof (GtkSocketClass),
- (GtkClassInitFunc) gtk_socket_class_init,
- (GtkObjectInitFunc) gtk_socket_init,
- (GtkArgSetFunc) NULL,
- (GtkArgGetFunc) NULL
+ NULL, /* base_init */
+ NULL, /* base_finalize */
+ (GClassInitFunc) gtk_socket_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GtkSocket),
+ 16, /* n_preallocs */
+ (GInstanceInitFunc) gtk_socket_init,
};
- socket_type = gtk_type_unique (GTK_TYPE_CONTAINER, &socket_info);
+ socket_type = g_type_register_static (GTK_TYPE_CONTAINER, "GtkSocket", &socket_info);
}
return socket_type;
static void gtk_spin_button_class_init (GtkSpinButtonClass *klass);
static void gtk_spin_button_init (GtkSpinButton *spin_button);
-static void gtk_spin_button_finalize (GtkObject *object);
+static void gtk_spin_button_finalize (GObject *object);
static void gtk_spin_button_set_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
static void
gtk_spin_button_class_init (GtkSpinButtonClass *class)
{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkEditableClass *editable_class;
parent_class = gtk_type_class (GTK_TYPE_ENTRY);
+ gobject_class->finalize = gtk_spin_button_finalize;
+
+ object_class->set_arg = gtk_spin_button_set_arg;
+ object_class->get_arg = gtk_spin_button_get_arg;
+
+ widget_class->map = gtk_spin_button_map;
+ widget_class->unmap = gtk_spin_button_unmap;
+ widget_class->realize = gtk_spin_button_realize;
+ widget_class->unrealize = gtk_spin_button_unrealize;
+ widget_class->size_request = gtk_spin_button_size_request;
+ widget_class->size_allocate = gtk_spin_button_size_allocate;
+ widget_class->draw = gtk_spin_button_draw;
+ widget_class->expose_event = gtk_spin_button_expose;
+ widget_class->scroll_event = gtk_spin_button_scroll;
+ widget_class->button_press_event = gtk_spin_button_button_press;
+ widget_class->button_release_event = gtk_spin_button_button_release;
+ widget_class->motion_notify_event = gtk_spin_button_motion_notify;
+ widget_class->key_press_event = gtk_spin_button_key_press;
+ widget_class->key_release_event = gtk_spin_button_key_release;
+ widget_class->enter_notify_event = gtk_spin_button_enter_notify;
+ widget_class->leave_notify_event = gtk_spin_button_leave_notify;
+ widget_class->focus_out_event = gtk_spin_button_focus_out;
+
+ editable_class->insert_text = gtk_spin_button_insert_text;
+ editable_class->activate = gtk_spin_button_activate;
+
+ class->input = NULL;
+ class->output = NULL;
+
gtk_object_add_arg_type ("GtkSpinButton::adjustment",
GTK_TYPE_ADJUSTMENT,
GTK_ARG_READWRITE,
GTK_ARG_READWRITE,
ARG_VALUE);
- object_class->set_arg = gtk_spin_button_set_arg;
- object_class->get_arg = gtk_spin_button_get_arg;
- object_class->finalize = gtk_spin_button_finalize;
-
spinbutton_signals[INPUT] =
gtk_signal_new ("input",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkSpinButtonClass, input),
gtk_marshal_INT__POINTER,
GTK_TYPE_INT, 1, GTK_TYPE_POINTER);
spinbutton_signals[OUTPUT] =
gtk_signal_new ("output",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkSpinButtonClass, output),
gtk_marshal_BOOL__NONE,
GTK_TYPE_BOOL, 0);
gtk_object_class_add_signals (object_class, spinbutton_signals, LAST_SIGNAL);
-
- widget_class->map = gtk_spin_button_map;
- widget_class->unmap = gtk_spin_button_unmap;
- widget_class->realize = gtk_spin_button_realize;
- widget_class->unrealize = gtk_spin_button_unrealize;
- widget_class->size_request = gtk_spin_button_size_request;
- widget_class->size_allocate = gtk_spin_button_size_allocate;
- widget_class->draw = gtk_spin_button_draw;
- widget_class->expose_event = gtk_spin_button_expose;
- widget_class->scroll_event = gtk_spin_button_scroll;
- widget_class->button_press_event = gtk_spin_button_button_press;
- widget_class->button_release_event = gtk_spin_button_button_release;
- widget_class->motion_notify_event = gtk_spin_button_motion_notify;
- widget_class->key_press_event = gtk_spin_button_key_press;
- widget_class->key_release_event = gtk_spin_button_key_release;
- widget_class->enter_notify_event = gtk_spin_button_enter_notify;
- widget_class->leave_notify_event = gtk_spin_button_leave_notify;
- widget_class->focus_out_event = gtk_spin_button_focus_out;
-
- editable_class->insert_text = gtk_spin_button_insert_text;
- editable_class->activate = gtk_spin_button_activate;
-
- class->input = NULL;
- class->output = NULL;
}
static void
}
static void
-gtk_spin_button_finalize (GtkObject *object)
+gtk_spin_button_finalize (GObject *object)
{
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (object));
gtk_object_unref (GTK_OBJECT (GTK_SPIN_BUTTON (object)->adjustment));
- GTK_OBJECT_CLASS (parent_class)->finalize (object);
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gtk_spin_button_set_adjustment (GtkSpinButton *spin_button,
GtkAdjustment *adjustment)
{
- g_return_if_fail (spin_button != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
if (spin_button->adjustment != adjustment)
static void gtk_statusbar_class_init (GtkStatusbarClass *class);
static void gtk_statusbar_init (GtkStatusbar *statusbar);
static void gtk_statusbar_destroy (GtkObject *object);
-static void gtk_statusbar_finalize (GtkObject *object);
static void gtk_statusbar_update (GtkStatusbar *statusbar,
guint context_id,
const gchar *text);
container_class = (GtkContainerClass *) class;
parent_class = gtk_type_class (GTK_TYPE_HBOX);
+
+ object_class->destroy = gtk_statusbar_destroy;
+
+ class->messages_mem_chunk = g_mem_chunk_new ("GtkStatusBar messages mem chunk",
+ sizeof (GtkStatusbarMsg),
+ sizeof (GtkStatusbarMsg) * 64,
+ G_ALLOC_AND_FREE);
+
+ class->text_pushed = gtk_statusbar_update;
+ class->text_popped = gtk_statusbar_update;
statusbar_signals[SIGNAL_TEXT_PUSHED] =
gtk_signal_new ("text_pushed",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkStatusbarClass, text_pushed),
gtk_marshal_NONE__UINT_STRING,
GTK_TYPE_NONE, 2,
statusbar_signals[SIGNAL_TEXT_POPPED] =
gtk_signal_new ("text_popped",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkStatusbarClass, text_popped),
gtk_marshal_NONE__UINT_STRING,
GTK_TYPE_NONE, 2,
GTK_TYPE_UINT,
GTK_TYPE_STRING);
gtk_object_class_add_signals (object_class, statusbar_signals, SIGNAL_LAST);
-
- object_class->destroy = gtk_statusbar_destroy;
- object_class->finalize = gtk_statusbar_finalize;
-
- class->messages_mem_chunk = g_mem_chunk_new ("GtkStatusBar messages mem chunk",
- sizeof (GtkStatusbarMsg),
- sizeof (GtkStatusbarMsg) * 64,
- G_ALLOC_AND_FREE);
-
- class->text_pushed = gtk_statusbar_update;
- class->text_popped = gtk_statusbar_update;
}
static void
g_return_val_if_fail (text != NULL, 0);
g_return_val_if_fail (context_id > 0, 0);
- class = GTK_STATUSBAR_CLASS (GTK_OBJECT (statusbar)->klass);
+ class = GTK_STATUSBAR_GET_CLASS (statusbar);
msg = g_chunk_new (GtkStatusbarMsg, class->messages_mem_chunk);
msg->text = g_strdup (text);
msg->context_id = context_id;
{
GtkStatusbarClass *class;
- class = GTK_STATUSBAR_CLASS (GTK_OBJECT (statusbar)->klass);
+ class = GTK_STATUSBAR_GET_CLASS (statusbar);
statusbar->messages = g_slist_remove_link (statusbar->messages,
list);
{
GtkStatusbarClass *class;
- class = GTK_STATUSBAR_CLASS (GTK_OBJECT (statusbar)->klass);
+ class = GTK_STATUSBAR_GET_CLASS (statusbar);
statusbar->messages = g_slist_remove_link (statusbar->messages, list);
g_free (msg->text);
g_mem_chunk_free (class->messages_mem_chunk, msg);
g_return_if_fail (GTK_IS_STATUSBAR (object));
statusbar = GTK_STATUSBAR (object);
- class = GTK_STATUSBAR_CLASS (GTK_OBJECT (statusbar)->klass);
+ class = GTK_STATUSBAR_GET_CLASS (statusbar);
for (list = statusbar->messages; list; list = list->next)
{
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
-
-static void
-gtk_statusbar_finalize (GtkObject *object)
-{
- GtkStatusbar *statusbar;
-
- g_return_if_fail (object != NULL);
- g_return_if_fail (GTK_IS_STATUSBAR (object));
-
- statusbar = GTK_STATUSBAR (object);
-
- GTK_OBJECT_CLASS (parent_class)->finalize (object);
-}
static void gtk_table_class_init (GtkTableClass *klass);
static void gtk_table_init (GtkTable *table);
-static void gtk_table_finalize (GtkObject *object);
+static void gtk_table_finalize (GObject *object);
static void gtk_table_map (GtkWidget *widget);
static void gtk_table_unmap (GtkWidget *widget);
static void gtk_table_draw (GtkWidget *widget,
static void
gtk_table_class_init (GtkTableClass *class)
{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkContainerClass *container_class;
container_class = (GtkContainerClass*) class;
parent_class = gtk_type_class (gtk_container_get_type ());
-
- gtk_object_add_arg_type ("GtkTable::n_rows", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_N_ROWS);
- gtk_object_add_arg_type ("GtkTable::n_columns", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_N_COLUMNS);
- gtk_object_add_arg_type ("GtkTable::row_spacing", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_ROW_SPACING);
- gtk_object_add_arg_type ("GtkTable::column_spacing", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_COLUMN_SPACING);
- gtk_object_add_arg_type ("GtkTable::homogeneous", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_HOMOGENEOUS);
- gtk_container_add_child_arg_type ("GtkTable::left_attach", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_LEFT_ATTACH);
- gtk_container_add_child_arg_type ("GtkTable::right_attach", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_RIGHT_ATTACH);
- gtk_container_add_child_arg_type ("GtkTable::top_attach", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_TOP_ATTACH);
- gtk_container_add_child_arg_type ("GtkTable::bottom_attach", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_BOTTOM_ATTACH);
- gtk_container_add_child_arg_type ("GtkTable::x_options", GTK_TYPE_ATTACH_OPTIONS, GTK_ARG_READWRITE, CHILD_ARG_X_OPTIONS);
- gtk_container_add_child_arg_type ("GtkTable::y_options", GTK_TYPE_ATTACH_OPTIONS, GTK_ARG_READWRITE, CHILD_ARG_Y_OPTIONS);
- gtk_container_add_child_arg_type ("GtkTable::x_padding", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_X_PADDING);
- gtk_container_add_child_arg_type ("GtkTable::y_padding", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_Y_PADDING);
+
+ gobject_class->finalize = gtk_table_finalize;
object_class->get_arg = gtk_table_get_arg;
object_class->set_arg = gtk_table_set_arg;
- object_class->finalize = gtk_table_finalize;
widget_class->map = gtk_table_map;
widget_class->unmap = gtk_table_unmap;
container_class->child_type = gtk_table_child_type;
container_class->set_child_arg = gtk_table_set_child_arg;
container_class->get_child_arg = gtk_table_get_child_arg;
+
+ gtk_object_add_arg_type ("GtkTable::n_rows", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_N_ROWS);
+ gtk_object_add_arg_type ("GtkTable::n_columns", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_N_COLUMNS);
+ gtk_object_add_arg_type ("GtkTable::row_spacing", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_ROW_SPACING);
+ gtk_object_add_arg_type ("GtkTable::column_spacing", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_COLUMN_SPACING);
+ gtk_object_add_arg_type ("GtkTable::homogeneous", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_HOMOGENEOUS);
+ gtk_container_add_child_arg_type ("GtkTable::left_attach", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_LEFT_ATTACH);
+ gtk_container_add_child_arg_type ("GtkTable::right_attach", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_RIGHT_ATTACH);
+ gtk_container_add_child_arg_type ("GtkTable::top_attach", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_TOP_ATTACH);
+ gtk_container_add_child_arg_type ("GtkTable::bottom_attach", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_BOTTOM_ATTACH);
+ gtk_container_add_child_arg_type ("GtkTable::x_options", GTK_TYPE_ATTACH_OPTIONS, GTK_ARG_READWRITE, CHILD_ARG_X_OPTIONS);
+ gtk_container_add_child_arg_type ("GtkTable::y_options", GTK_TYPE_ATTACH_OPTIONS, GTK_ARG_READWRITE, CHILD_ARG_Y_OPTIONS);
+ gtk_container_add_child_arg_type ("GtkTable::x_padding", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_X_PADDING);
+ gtk_container_add_child_arg_type ("GtkTable::y_padding", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_Y_PADDING);
}
static GtkType
}
static void
-gtk_table_finalize (GtkObject *object)
+gtk_table_finalize (GObject *object)
{
GtkTable *table;
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_TABLE (object));
table = GTK_TABLE (object);
g_free (table->rows);
g_free (table->cols);
- (* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
guint arg_id);
static void gtk_text_init (GtkText *text);
static void gtk_text_destroy (GtkObject *object);
-static void gtk_text_finalize (GtkObject *object);
+static void gtk_text_finalize (GObject *object);
static void gtk_text_realize (GtkWidget *widget);
static void gtk_text_unrealize (GtkWidget *widget);
static void gtk_text_style_set (GtkWidget *widget,
static void
gtk_text_class_init (GtkTextClass *class)
{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkEditableClass *editable_class;
editable_class = (GtkEditableClass*) class;
parent_class = gtk_type_class (GTK_TYPE_EDITABLE);
- gtk_object_add_arg_type ("GtkText::hadjustment",
- GTK_TYPE_ADJUSTMENT,
- GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
- ARG_HADJUSTMENT);
- gtk_object_add_arg_type ("GtkText::vadjustment",
- GTK_TYPE_ADJUSTMENT,
- GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
- ARG_VADJUSTMENT);
- gtk_object_add_arg_type ("GtkText::line_wrap",
- GTK_TYPE_BOOL,
- GTK_ARG_READWRITE,
- ARG_LINE_WRAP);
- gtk_object_add_arg_type ("GtkText::word_wrap",
- GTK_TYPE_BOOL,
- GTK_ARG_READWRITE,
- ARG_WORD_WRAP);
+ gobject_class->finalize = gtk_text_finalize;
object_class->set_arg = gtk_text_set_arg;
object_class->get_arg = gtk_text_get_arg;
object_class->destroy = gtk_text_destroy;
- object_class->finalize = gtk_text_finalize;
widget_class->realize = gtk_text_realize;
widget_class->unrealize = gtk_text_unrealize;
widget_class->key_press_event = gtk_text_key_press;
widget_class->focus_in_event = gtk_text_focus_in;
widget_class->focus_out_event = gtk_text_focus_out;
-
- widget_class->set_scroll_adjustments_signal =
- gtk_signal_new ("set_scroll_adjustments",
- GTK_RUN_LAST,
- object_class->type,
- GTK_SIGNAL_OFFSET (GtkTextClass, set_scroll_adjustments),
- gtk_marshal_NONE__POINTER_POINTER,
- GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
editable_class->set_editable = gtk_text_real_set_editable;
editable_class->insert_text = gtk_text_insert_text;
editable_class->set_position = gtk_text_set_position;
class->set_scroll_adjustments = gtk_text_set_adjustments;
+
+ gtk_object_add_arg_type ("GtkText::hadjustment",
+ GTK_TYPE_ADJUSTMENT,
+ GTK_ARG_READWRITE,
+ ARG_HADJUSTMENT);
+ gtk_object_add_arg_type ("GtkText::vadjustment",
+ GTK_TYPE_ADJUSTMENT,
+ GTK_ARG_READWRITE,
+ ARG_VADJUSTMENT);
+ gtk_object_add_arg_type ("GtkText::line_wrap",
+ GTK_TYPE_BOOL,
+ GTK_ARG_READWRITE,
+ ARG_LINE_WRAP);
+ gtk_object_add_arg_type ("GtkText::word_wrap",
+ GTK_TYPE_BOOL,
+ GTK_ARG_READWRITE,
+ ARG_WORD_WRAP);
+
+ widget_class->set_scroll_adjustments_signal =
+ gtk_signal_new ("set_scroll_adjustments",
+ GTK_RUN_LAST,
+ GTK_CLASS_TYPE (object_class),
+ GTK_SIGNAL_OFFSET (GtkTextClass, set_scroll_adjustments),
+ gtk_marshal_NONE__POINTER_POINTER,
+ GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
}
static void
GTK_EDITABLE (text)->editable = FALSE;
+ gtk_text_set_adjustments (text, NULL, NULL);
gtk_editable_set_position (GTK_EDITABLE (text), 0);
}
{
GtkText *text;
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_TEXT (object));
- text = (GtkText*) object;
+ text = GTK_TEXT (object);
- gtk_signal_disconnect_by_data (GTK_OBJECT (text->hadj), text);
- gtk_signal_disconnect_by_data (GTK_OBJECT (text->vadj), text);
+ if (text->hadj)
+ {
+ gtk_signal_disconnect_by_data (GTK_OBJECT (text->hadj), text);
+ gtk_object_unref (GTK_OBJECT (text->hadj));
+ text->hadj = NULL;
+ }
+ if (text->vadj)
+ {
+ gtk_signal_disconnect_by_data (GTK_OBJECT (text->vadj), text);
+ gtk_object_unref (GTK_OBJECT (text->vadj));
+ text->vadj = NULL;
+ }
if (text->timer)
{
}
static void
-gtk_text_finalize (GtkObject *object)
+gtk_text_finalize (GObject *object)
{
GtkText *text;
GList *tmp_list;
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_TEXT (object));
- text = (GtkText *)object;
-
- gtk_object_unref (GTK_OBJECT (text->hadj));
- gtk_object_unref (GTK_OBJECT (text->vadj));
+ text = GTK_TEXT (object);
/* Clean up the internal structures */
if (text->use_wchar)
g_list_free (text->tab_stops);
- GTK_OBJECT_CLASS(parent_class)->finalize (object);
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
tips_query_signals[SIGNAL_START_QUERY] =
gtk_signal_new ("start_query",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkTipsQueryClass, start_query),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
tips_query_signals[SIGNAL_STOP_QUERY] =
gtk_signal_new ("stop_query",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkTipsQueryClass, stop_query),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
tips_query_signals[SIGNAL_WIDGET_ENTERED] =
gtk_signal_new ("widget_entered",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkTipsQueryClass, widget_entered),
gtk_marshal_NONE__POINTER_STRING_STRING,
GTK_TYPE_NONE, 3,
tips_query_signals[SIGNAL_WIDGET_SELECTED] =
gtk_signal_new ("widget_selected",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkTipsQueryClass, widget_selected),
gtk_marshal_BOOL__POINTER_STRING_STRING_POINTER,
GTK_TYPE_BOOL, 4,
toggle_button_signals[TOGGLED] =
gtk_signal_new ("toggled",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkToggleButtonClass, toggled),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
toolbar_signals[ORIENTATION_CHANGED] =
gtk_signal_new ("orientation_changed",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkToolbarClass, orientation_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
toolbar_signals[STYLE_CHANGED] =
gtk_signal_new ("style_changed",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkToolbarClass, style_changed),
gtk_marshal_NONE__INT,
GTK_TYPE_NONE, 1,
toolbar = GTK_TOOLBAR (object);
- gtk_object_unref (GTK_OBJECT (toolbar->tooltips));
- toolbar->tooltips = NULL;
+ if (toolbar->tooltips)
+ {
+ gtk_object_unref (GTK_OBJECT (toolbar->tooltips));
+ toolbar->tooltips = NULL;
+ }
for (children = toolbar->children; children; children = children->next)
{
g_free (child);
}
-
g_list_free (toolbar->children);
toolbar->children = NULL;
- if (GTK_OBJECT_CLASS (parent_class)->destroy)
- (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+ GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
static void
tree_signals[SELECTION_CHANGED] =
gtk_signal_new ("selection_changed",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkTreeClass, selection_changed),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
tree_signals[SELECT_CHILD] =
gtk_signal_new ("select_child",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkTreeClass, select_child),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1,
tree_signals[UNSELECT_CHILD] =
gtk_signal_new ("unselect_child",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkTreeClass, unselect_child),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1,
tree_item_signals[EXPAND_TREE] =
gtk_signal_new ("expand",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkTreeItemClass, expand),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
tree_item_signals[COLLAPSE_TREE] =
gtk_signal_new ("collapse",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkTreeItemClass, collapse),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
*/
/*
- * Modified by the GTK+ Team and others 1997-1999. See the AUTHORS
+ * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
-#include <string.h>
#include "gtktypeutils.h"
+#include "gtkobject.h"
-#define TYPE_NODES_BLOCK_SIZE (35) /* needs to be > GTK_TYPE_FUNDAMENTAL_MAX */
-
-typedef struct _GtkTypeNode GtkTypeNode;
-
-struct _GtkTypeNode
+/* --- functions --- */
+GtkType
+gtk_type_unique (GtkType parent_type,
+ const GtkTypeInfo *gtkinfo)
{
- GtkType type;
- GtkTypeInfo type_info;
- guint n_supers : 24;
- guint chunk_alloc_locked : 1;
- GtkType *supers;
- GtkType parent_type;
- gpointer klass;
- GList *children_types;
- GMemChunk *mem_chunk;
-};
-
-#define LOOKUP_TYPE_NODE(node_var, type) { \
- GtkTypeNode *__node = NULL; \
- GtkType sqn = GTK_TYPE_SEQNO (type); \
- if (sqn > 0) \
- { \
- sqn--; \
- if (sqn < GTK_TYPE_FUNDAMENTAL_MAX) \
- { \
- if (sqn < n_ftype_nodes) \
- __node = type_nodes + sqn; \
- } \
- else if (sqn < n_type_nodes) \
- __node = type_nodes + sqn; \
- } \
- node_var = __node; \
-}
-
-static void gtk_type_class_init (GtkType node_type);
-static void gtk_type_init_builtin_types (void);
+ GTypeInfo tinfo = { 0, };
-static GtkTypeNode *type_nodes = NULL;
-static guint n_type_nodes = 0;
-static guint n_ftype_nodes = 0;
-static GHashTable *type_name_2_type_ht = NULL;
+ g_return_val_if_fail (GTK_TYPE_IS_OBJECT (parent_type), 0);
+ g_return_val_if_fail (gtkinfo != NULL, 0);
+ g_return_val_if_fail (gtkinfo->type_name != NULL, 0);
+ g_return_val_if_fail (g_type_from_name (gtkinfo->type_name) == 0, 0);
+ tinfo.class_size = gtkinfo->class_size;
+ tinfo.base_init = gtkinfo->base_class_init_func;
+ tinfo.base_finalize = NULL;
+ tinfo.class_init = (GClassInitFunc) gtkinfo->class_init_func;
+ tinfo.class_finalize = NULL;
+ tinfo.class_data = NULL;
+ tinfo.instance_size = gtkinfo->object_size;
+ tinfo.n_preallocs = 0;
+ tinfo.instance_init = gtkinfo->object_init_func;
-static GtkTypeNode*
-gtk_type_node_next_and_invalidate (GtkType parent_type)
-{
- static guint n_free_type_nodes = 0;
- GtkTypeNode *node;
-
- /* don't keep *any* GtkTypeNode pointers across invokation of this function!!!
- */
-
- if (n_free_type_nodes == 0)
- {
- guint i;
- guint size;
-
- /* nearest pow
- */
- size = n_type_nodes + TYPE_NODES_BLOCK_SIZE;
- size *= sizeof (GtkTypeNode);
- i = 1;
- while (i < size)
- i <<= 1;
- size = i;
-
- type_nodes = g_realloc (type_nodes, size);
-
- n_free_type_nodes = size / sizeof (GtkTypeNode) - n_type_nodes;
-
- memset (type_nodes + n_type_nodes, 0, n_free_type_nodes * sizeof (GtkTypeNode));
- if (!n_type_nodes)
- {
- n_type_nodes = GTK_TYPE_FUNDAMENTAL_MAX;
- n_free_type_nodes -= GTK_TYPE_FUNDAMENTAL_MAX;
- }
- }
-
- if (!parent_type)
- {
- g_assert (n_ftype_nodes < GTK_TYPE_FUNDAMENTAL_MAX); /* paranoid */
-
- node = type_nodes + n_ftype_nodes;
- n_ftype_nodes++;
- node->type = n_ftype_nodes;
- }
- else
- {
- node = type_nodes + n_type_nodes;
- n_type_nodes++;
- n_free_type_nodes--;
- node->type = GTK_TYPE_MAKE (parent_type, n_type_nodes);
- }
-
- return node;
-}
-
-void
-gtk_type_init (void)
-{
- if (n_type_nodes == 0)
- {
- g_assert (sizeof (GtkType) >= 4);
- g_assert (TYPE_NODES_BLOCK_SIZE > GTK_TYPE_FUNDAMENTAL_MAX);
-
- type_name_2_type_ht = g_hash_table_new (g_str_hash, g_str_equal);
-
- gtk_type_init_builtin_types ();
- }
+ return g_type_register_static (parent_type, gtkinfo->type_name, &tinfo);
}
-void
-gtk_type_set_chunk_alloc (GtkType type,
- guint n_chunks)
-{
- GtkTypeNode *node;
-
- LOOKUP_TYPE_NODE (node, type);
- g_return_if_fail (node != NULL);
- g_return_if_fail (node->chunk_alloc_locked == FALSE);
-
- if (node->mem_chunk)
- {
- g_mem_chunk_destroy (node->mem_chunk);
- node->mem_chunk = NULL;
- }
-
- if (n_chunks)
- node->mem_chunk = g_mem_chunk_new (node->type_info.type_name,
- node->type_info.object_size,
- node->type_info.object_size * n_chunks,
- G_ALLOC_AND_FREE);
-}
-
-static GtkType
-gtk_type_create (GtkType parent_type,
- gchar *type_name,
- const GtkTypeInfo *type_info)
+gpointer
+gtk_type_class (GtkType type)
{
- GtkTypeNode *new_node;
- GtkTypeNode *parent;
- guint i;
-
- if (g_hash_table_lookup (type_name_2_type_ht, type_name))
- {
- g_warning ("gtk_type_create(): type `%s' already exists.", type_name);
- return 0;
- }
-
- if (parent_type)
- {
- GtkTypeNode *tmp_node;
-
- LOOKUP_TYPE_NODE (tmp_node, parent_type);
- if (!tmp_node)
- {
- g_warning ("gtk_type_create(): unknown parent type `%u'.", parent_type);
- return 0;
- }
- }
-
- /* relookup pointers afterwards.
+ static GQuark quark_static_class = 0;
+ gpointer class;
+
+ if (!G_TYPE_IS_ENUM (type) && !G_TYPE_IS_FLAGS (type))
+ g_return_val_if_fail (GTK_TYPE_IS_OBJECT (type), NULL);
+
+ /* ok, this is a bit ugly, GLib reference counts classes,
+ * and gtk_type_class() used to always return static classes.
+ * while we coud be faster with just peeking the glib class
+ * for the normal code path, we can't be sure that that
+ * class stays around (someone else might be holding the
+ * reference count and is going to drop it later). so to
+ * ensure that Gtk actually holds a static reference count
+ * on the class, we use GType qdata to store referenced
+ * classes, and only return those.
*/
- new_node = gtk_type_node_next_and_invalidate (parent_type);
-
- if (parent_type)
- {
- g_assert (GTK_TYPE_SEQNO (new_node->type) > GTK_TYPE_FUNDAMENTAL_MAX);
- LOOKUP_TYPE_NODE (parent, parent_type);
- }
- else
- {
- g_assert (new_node->type <= GTK_TYPE_FUNDAMENTAL_MAX);
- parent = NULL;
- }
-
- new_node->type_info = *type_info;
- new_node->type_info.type_name = type_name;
- /* new_node->type_info.reserved_1 = NULL; */
- new_node->type_info.reserved_2 = NULL;
- new_node->n_supers = parent ? parent->n_supers + 1 : 0;
- new_node->chunk_alloc_locked = FALSE;
- new_node->supers = g_new0 (GtkType, new_node->n_supers + 1);
- new_node->parent_type = parent_type;
- new_node->klass = NULL;
- new_node->children_types = NULL;
- new_node->mem_chunk = NULL;
-
- if (parent)
- parent->children_types = g_list_append (parent->children_types, GUINT_TO_POINTER (new_node->type));
-
- parent = new_node;
- for (i = 0; i < new_node->n_supers + 1; i++)
- {
- new_node->supers[i] = parent->type;
- LOOKUP_TYPE_NODE (parent, parent->parent_type);
- }
-
- g_hash_table_insert (type_name_2_type_ht, new_node->type_info.type_name, GUINT_TO_POINTER (new_node->type));
-
- return new_node->type;
-}
-GtkType
-gtk_type_unique (GtkType parent_type,
- const GtkTypeInfo *type_info)
-{
- GtkType new_type;
- gchar *type_name;
-
- g_return_val_if_fail (type_info != NULL, 0);
- g_return_val_if_fail (type_info->type_name != NULL, 0);
-
- if (!parent_type && n_ftype_nodes >= GTK_TYPE_FUNDAMENTAL_MAX)
+ class = g_type_get_qdata (type, quark_static_class);
+ if (!class)
{
- g_warning ("gtk_type_unique(): maximum amount of fundamental types reached, "
- "try increasing GTK_TYPE_FUNDAMENTAL_MAX");
- return 0;
- }
-
- type_name = g_strdup (type_info->type_name);
-
- /* relookup pointers afterwards.
- */
- new_type = gtk_type_create (parent_type, type_name, type_info);
-
- if (!new_type)
- g_free (type_name);
+ if (!quark_static_class)
+ quark_static_class = g_quark_from_static_string ("GtkStaticTypeClass");
- return new_type;
-}
-
-gchar*
-gtk_type_name (GtkType type)
-{
- GtkTypeNode *node;
-
- LOOKUP_TYPE_NODE (node, type);
-
- if (node)
- return node->type_info.type_name;
-
- return NULL;
-}
-
-GtkType
-gtk_type_from_name (const gchar *name)
-{
- if (type_name_2_type_ht)
- {
- GtkType type;
-
- type = GPOINTER_TO_UINT (g_hash_table_lookup (type_name_2_type_ht, (gpointer) name));
-
- return type;
- }
-
- return 0;
-}
-
-GtkType
-gtk_type_parent (GtkType type)
-{
- GtkTypeNode *node;
-
- LOOKUP_TYPE_NODE (node, type);
- if (node)
- return node->parent_type;
-
- return 0;
-}
-
-gpointer
-gtk_type_parent_class (GtkType type)
-{
- GtkTypeNode *node;
-
- LOOKUP_TYPE_NODE (node, type);
- g_return_val_if_fail (node != NULL, NULL);
-
- if (node)
- {
- LOOKUP_TYPE_NODE (node, node->parent_type);
-
- if (node)
- {
- if (!node->klass)
- {
- type = node->type;
- gtk_type_class_init (type);
- LOOKUP_TYPE_NODE (node, type);
- }
-
- return node->klass;
- }
+ class = g_type_class_ref (type);
+ g_assert (class != NULL);
+ g_type_set_qdata (type, quark_static_class, class);
}
-
- return NULL;
-}
-gpointer
-gtk_type_class (GtkType type)
-{
- GtkTypeNode *node;
-
- LOOKUP_TYPE_NODE (node, type);
- g_return_val_if_fail (node != NULL, NULL);
-
- if (!node->klass)
- {
- type = node->type;
- gtk_type_class_init (type);
- LOOKUP_TYPE_NODE (node, type);
- }
-
- return node->klass;
+ return class;
}
gpointer
gtk_type_new (GtkType type)
{
- GtkTypeNode *node;
- GtkTypeObject *tobject;
- gpointer klass;
-
- LOOKUP_TYPE_NODE (node, type);
- g_return_val_if_fail (node != NULL, NULL);
-
- klass = node->klass;
- if (!klass)
- {
- klass = gtk_type_class (type);
- LOOKUP_TYPE_NODE (node, type);
- }
- node->chunk_alloc_locked = TRUE;
-
- if (node->mem_chunk)
- tobject = g_mem_chunk_alloc0 (node->mem_chunk);
- else
- tobject = g_malloc0 (node->type_info.object_size);
-
- /* we need to call the base classes' object_init_func for derived
- * objects with the object's ->klass field still pointing to the
- * corresponding base class, otherwise overridden class functions
- * could get called with partly-initialized objects. the real object
- * class is passed as second argment to the initializers.
- */
- if (node->n_supers)
- {
- guint i;
- GtkType *supers;
- GtkTypeNode *pnode;
+ gpointer object;
- supers = node->supers;
- for (i = node->n_supers; i > 0; i--)
- {
- LOOKUP_TYPE_NODE (pnode, supers[i]);
- if (pnode->type_info.object_init_func)
- {
- tobject->klass = pnode->klass;
- pnode->type_info.object_init_func (tobject, klass);
- }
- }
- LOOKUP_TYPE_NODE (node, type);
- }
- tobject->klass = klass;
- if (node->type_info.object_init_func)
- {
- node->type_info.object_init_func (tobject, klass);
- tobject->klass = klass;
- }
-
- return tobject;
-}
+ g_return_val_if_fail (GTK_TYPE_IS_OBJECT (type), NULL);
-void
-gtk_type_free (GtkType type,
- gpointer mem)
-{
- GtkTypeNode *node;
-
- g_return_if_fail (mem != NULL);
- LOOKUP_TYPE_NODE (node, type);
- g_return_if_fail (node != NULL);
-
- if (node->mem_chunk)
- g_mem_chunk_free (node->mem_chunk, mem);
- else
- g_free (mem);
-}
+ object = g_type_create_instance (type);
-GList*
-gtk_type_children_types (GtkType type)
-{
- GtkTypeNode *node;
-
- LOOKUP_TYPE_NODE (node, type);
- if (node)
- return node->children_types;
-
- return NULL;
+ return object;
}
-void
-gtk_type_describe_heritage (GtkType type)
-{
- GtkTypeNode *node;
- gchar *is_a = "";
-
- LOOKUP_TYPE_NODE (node, type);
-
- while (node)
- {
- if (node->type_info.type_name)
- g_message ("%s%s",
- is_a,
- node->type_info.type_name);
- else
- g_message ("%s<unnamed type>",
- is_a);
- is_a = "is a ";
-
- LOOKUP_TYPE_NODE (node, node->parent_type);
- }
-}
+/* includes for various places
+ * with enum definitions
+ */
+#include "makeenums.h"
+/* type variable declarations
+ */
+#include "gtktypebuiltins_vars.c"
+GType GTK_TYPE_IDENTIFIER = 0;
+#include "gtktypebuiltins_evals.c" /* enum value definition arrays */
void
-gtk_type_describe_tree (GtkType type,
- gboolean show_size)
+gtk_type_init (void)
{
- GtkTypeNode *node;
-
- LOOKUP_TYPE_NODE (node, type);
-
- if (node)
- {
- static gint indent = 0;
- GList *list;
- guint old_indent;
+ static gboolean initialized = FALSE;
+
+ if (!initialized)
+ {
+ static const struct {
+ GtkType type_id;
+ gchar *name;
+ } fundamental_info[] = {
+ { GTK_TYPE_CHAR, "gchar" },
+ { GTK_TYPE_UCHAR, "guchar" },
+ { GTK_TYPE_BOOL, "gboolean" },
+ { GTK_TYPE_INT, "gint" },
+ { GTK_TYPE_UINT, "guint" },
+ { GTK_TYPE_LONG, "glong" },
+ { GTK_TYPE_ULONG, "gulong" },
+ { GTK_TYPE_FLOAT, "gfloat" },
+ { GTK_TYPE_DOUBLE, "gdouble" },
+ { GTK_TYPE_POINTER, "gpointer" },
+ { GTK_TYPE_SIGNAL, "GtkSignal" },
+ };
+ static struct {
+ gchar *type_name;
+ GtkType *type_id;
+ GtkType parent;
+ const GtkEnumValue *values;
+ } builtin_info[GTK_TYPE_N_BUILTINS + 1] = {
+#include "gtktypebuiltins_ids.c" /* type entries */
+ { NULL }
+ };
+ GTypeFundamentalInfo finfo = { 0, };
+ GTypeInfo tinfo = { 0, };
+ GtkType type_id;
guint i;
- GString *gstring;
- gstring = g_string_new ("");
-
- for (i = 0; i < indent; i++)
- g_string_append_c (gstring, ' ');
-
- if (node->type_info.type_name)
- g_string_append (gstring, node->type_info.type_name);
- else
- g_string_append (gstring, "<unnamed type>");
-
- if (show_size)
- g_string_sprintfa (gstring, " (%d bytes)", node->type_info.object_size);
+ initialized = TRUE;
- g_message ("%s", gstring->str);
- g_string_free (gstring, TRUE);
-
- old_indent = indent;
- indent += 4;
-
- for (list = node->children_types; list; list = list->next)
- gtk_type_describe_tree (GPOINTER_TO_UINT (list->data), show_size);
+ /* initialize GLib type system
+ */
+ g_type_init ();
- indent = old_indent;
- }
-}
+ /* GTK_TYPE_OBJECT
+ */
+ gtk_object_get_type ();
-gboolean
-gtk_type_is_a (GtkType type,
- GtkType is_a_type)
-{
- if (type == is_a_type)
- return TRUE;
- else
- {
- GtkTypeNode *node;
-
- LOOKUP_TYPE_NODE (node, type);
- if (node)
+ /* compatibility fundamentals
+ */
+ for (i = 0; i < sizeof (fundamental_info) / sizeof (fundamental_info[0]); i++)
{
- GtkTypeNode *a_node;
-
- LOOKUP_TYPE_NODE (a_node, is_a_type);
- if (a_node)
- {
- if (a_node->n_supers <= node->n_supers)
- return node->supers[node->n_supers - a_node->n_supers] == is_a_type;
- }
+ type_id = g_type_register_fundamental (fundamental_info[i].type_id,
+ fundamental_info[i].name,
+ &finfo,
+ &tinfo);
+ g_assert (type_id == fundamental_info[i].type_id);
}
- }
-
- return FALSE;
-}
-static void
-gtk_type_class_init (GtkType type)
-{
- GtkTypeNode *node;
+ /* GTK_TYPE_STRING & GTK_TYPE_IDENTIFIER
+ */
+ finfo.type_flags = G_TYPE_FLAG_DERIVABLE;
+ type_id = g_type_register_fundamental (GTK_TYPE_STRING, "GtkString", &finfo, &tinfo);
+ g_assert (type_id == GTK_TYPE_STRING);
+ GTK_TYPE_IDENTIFIER = g_type_register_static (GTK_TYPE_STRING, "GtkIdentifier", &tinfo);
- /* we need to relookup nodes everytime we called an external function */
- LOOKUP_TYPE_NODE (node, type);
-
- if (!node->klass && node->type_info.class_size)
- {
- GtkTypeClass *type_class;
- GtkTypeNode *base_node;
- GSList *slist;
-
- if (node->type_info.class_size < sizeof (GtkTypeClass))
- g_warning ("The `%s' class is too small to inherit from GtkTypeClass",
- node->type_info.type_name);
-
- node->klass = g_malloc0 (node->type_info.class_size);
-
- if (node->parent_type)
- {
- GtkTypeNode *parent;
-
- LOOKUP_TYPE_NODE (parent, node->parent_type);
-
- if (node->type_info.class_size < parent->type_info.class_size)
- g_warning ("The `%s' class is smaller than its parent class `%s'",
- node->type_info.type_name,
- parent->type_info.type_name);
-
- if (!parent->klass)
- {
- gtk_type_class_init (parent->type);
- LOOKUP_TYPE_NODE (node, type);
- LOOKUP_TYPE_NODE (parent, node->parent_type);
- }
-
- if (parent->klass)
- memcpy (node->klass, parent->klass, parent->type_info.class_size);
- }
-
- type_class = node->klass;
- type_class->type = node->type;
-
- /* stack all base class initialization functions, so we
- * call them in ascending order.
+ /* GTK_TYPE_BOXED
*/
- base_node = node;
- slist = NULL;
- while (base_node)
- {
- if (base_node->type_info.base_class_init_func)
- slist = g_slist_prepend (slist, base_node->type_info.base_class_init_func);
- LOOKUP_TYPE_NODE (base_node, base_node->parent_type);
- }
- if (slist)
+ finfo.type_flags = G_TYPE_FLAG_DERIVABLE;
+ type_id = g_type_register_fundamental (GTK_TYPE_BOXED, "GtkBoxed", &finfo, &tinfo);
+ g_assert (type_id == GTK_TYPE_BOXED);
+
+ /* enums and flags
+ */
+ for (i = 0; i < GTK_TYPE_N_BUILTINS; i++)
{
- GSList *walk;
-
- for (walk = slist; walk; walk = walk->next)
- {
- GtkClassInitFunc base_class_init;
-
- base_class_init = walk->data;
- base_class_init (node->klass);
- LOOKUP_TYPE_NODE (node, type);
- }
- g_slist_free (slist);
+ GtkType type_id = 0;
+
+ if (builtin_info[i].parent == G_TYPE_ENUM)
+ type_id = g_enum_register_static (builtin_info[i].type_name, builtin_info[i].values);
+ else if (builtin_info[i].parent == G_TYPE_FLAGS)
+ type_id = g_flags_register_static (builtin_info[i].type_name, builtin_info[i].values);
+ else if (builtin_info[i].parent == GTK_TYPE_BOXED)
+ type_id = g_type_register_static (GTK_TYPE_BOXED, builtin_info[i].type_name, &tinfo);
+ else
+ g_assert_not_reached ();
+
+ *builtin_info[i].type_id = type_id;
}
-
- if (node->type_info.class_init_func)
- node->type_info.class_init_func (node->klass);
- }
-}
-
-static inline gchar*
-gtk_type_descriptive_name (GtkType type)
-{
- gchar *name;
-
- name = gtk_type_name (type);
- if (!name)
- name = "(unknown)";
-
- return name;
-}
-
-GtkTypeObject*
-gtk_type_check_object_cast (GtkTypeObject *type_object,
- GtkType cast_type)
-{
- if (!type_object)
- {
- g_warning ("invalid cast from (NULL) pointer to `%s'",
- gtk_type_descriptive_name (cast_type));
- return type_object;
}
- if (!type_object->klass)
- {
- g_warning ("invalid unclassed pointer in cast to `%s'",
- gtk_type_descriptive_name (cast_type));
- return type_object;
- }
- /* currently, GTK_TYPE_OBJECT is the lowest fundamental type
- * dominator for types that introduce classes.
- */
- if (type_object->klass->type < GTK_TYPE_OBJECT)
- {
- g_warning ("invalid class type `%s' in cast to `%s'",
- gtk_type_descriptive_name (type_object->klass->type),
- gtk_type_descriptive_name (cast_type));
- return type_object;
- }
- if (!gtk_type_is_a (type_object->klass->type, cast_type))
- {
- g_warning ("invalid cast from `%s' to `%s'",
- gtk_type_descriptive_name (type_object->klass->type),
- gtk_type_descriptive_name (cast_type));
- return type_object;
- }
-
- return type_object;
-}
-
-GtkTypeClass*
-gtk_type_check_class_cast (GtkTypeClass *klass,
- GtkType cast_type)
-{
- if (!klass)
- {
- g_warning ("invalid class cast from (NULL) pointer to `%s'",
- gtk_type_descriptive_name (cast_type));
- return klass;
- }
- /* currently, GTK_TYPE_OBJECT is the lowest fundamental type
- * dominator for types that introduce classes.
- */
- if (klass->type < GTK_TYPE_OBJECT)
- {
- g_warning ("invalid class type `%s' in class cast to `%s'",
- gtk_type_descriptive_name (klass->type),
- gtk_type_descriptive_name (cast_type));
- return klass;
- }
- if (!gtk_type_is_a (klass->type, cast_type))
- {
- g_warning ("invalid class cast from `%s' to `%s'",
- gtk_type_descriptive_name (klass->type),
- gtk_type_descriptive_name (cast_type));
- return klass;
- }
-
- return klass;
}
GtkEnumValue*
-gtk_type_enum_get_values (GtkType enum_type)
-{
- if (GTK_FUNDAMENTAL_TYPE (enum_type) == GTK_TYPE_ENUM ||
- GTK_FUNDAMENTAL_TYPE (enum_type) == GTK_TYPE_FLAGS)
- {
- GtkTypeNode *node;
-
- LOOKUP_TYPE_NODE (node, enum_type);
- if (node)
- return (GtkEnumValue*) node->type_info.reserved_1;
- }
-
- g_warning ("gtk_type_enum_get_values(): type `%s' is not derived from `GtkEnum' or `GtkFlags'",
- gtk_type_name (enum_type));
-
- return NULL;
-}
-
-GtkFlagValue*
-gtk_type_flags_get_values (GtkType flags_type)
+gtk_type_enum_get_values (GtkType enum_type)
{
- return gtk_type_enum_get_values (flags_type);
-}
+ GEnumClass *class;
-GtkEnumValue*
-gtk_type_enum_find_value (GtkType enum_type,
- const gchar *value_name)
-{
- g_return_val_if_fail (value_name != NULL, NULL);
+ g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL);
- if (GTK_FUNDAMENTAL_TYPE (enum_type) == GTK_TYPE_ENUM ||
- GTK_FUNDAMENTAL_TYPE (enum_type) == GTK_TYPE_FLAGS)
- {
- GtkEnumValue *vals;
-
- vals = gtk_type_enum_get_values (enum_type);
- if (vals)
- while (vals->value_name)
- {
- if (strcmp (vals->value_name, value_name) == 0 ||
- strcmp (vals->value_nick, value_name) == 0)
- return vals;
- vals++;
- }
- }
- else
- g_warning ("gtk_type_enum_find_value(): type `%s' is not derived from `GtkEnum' or `GtkFlags'",
- gtk_type_name (enum_type));
+ class = gtk_type_class (enum_type);
- return NULL;
+ return class->values;
}
GtkFlagValue*
-gtk_type_flags_find_value (GtkType flag_type,
- const gchar *value_name)
-{
- g_return_val_if_fail (value_name != NULL, NULL);
-
- return gtk_type_enum_find_value (flag_type, value_name);
-}
-
-typedef struct _GtkTypeVarargType GtkTypeVarargType;
-struct _GtkTypeVarargType
+gtk_type_flags_get_values (GtkType flags_type)
{
- GtkType foreign_type;
- GtkType varargs_type;
-};
-
-static GtkTypeVarargType *vararg_types = NULL;
-static guint n_vararg_types = 0;
+ GFlagsClass *class;
-void
-gtk_type_set_varargs_type (GtkType foreign_type,
- GtkType varargs_type)
-{
- g_return_if_fail (foreign_type == GTK_FUNDAMENTAL_TYPE (foreign_type));
- g_return_if_fail (foreign_type > GTK_TYPE_FUNDAMENTAL_LAST);
-
- if (!((varargs_type >= GTK_TYPE_STRUCTURED_FIRST &&
- varargs_type <= GTK_TYPE_STRUCTURED_LAST) ||
- (varargs_type >= GTK_TYPE_FLAT_FIRST &&
- varargs_type <= GTK_TYPE_FLAT_LAST) ||
- varargs_type == GTK_TYPE_NONE))
- {
- g_warning ("invalid varargs type `%s' for fundamental type `%s'",
- gtk_type_name (varargs_type),
- gtk_type_name (foreign_type));
- return;
- }
- if (gtk_type_get_varargs_type (foreign_type))
- {
- g_warning ("varargs type is already registered for fundamental type `%s'",
- gtk_type_name (foreign_type));
- return;
- }
+ g_return_val_if_fail (G_TYPE_IS_FLAGS (flags_type), NULL);
- n_vararg_types++;
- vararg_types = g_realloc (vararg_types, sizeof (GtkTypeVarargType) * n_vararg_types);
+ class = gtk_type_class (flags_type);
- vararg_types[n_vararg_types - 1].foreign_type = foreign_type;
- vararg_types[n_vararg_types - 1].varargs_type = varargs_type;
+ return class->values;
}
-GtkType
-gtk_type_get_varargs_type (GtkType foreign_type)
+GtkEnumValue*
+gtk_type_enum_find_value (GtkType enum_type,
+ const gchar *value_name)
{
- GtkType type;
- guint i;
-
- type = GTK_FUNDAMENTAL_TYPE (foreign_type);
- if (type <= GTK_TYPE_FUNDAMENTAL_LAST)
- return type;
-
- for (i = 0; i < n_vararg_types; i++)
- if (vararg_types[i].foreign_type == type)
- return vararg_types[i].varargs_type;
+ GtkEnumValue *value;
+ GEnumClass *class;
- return 0;
-}
-
-static inline GtkType
-gtk_type_register_intern (gchar *name,
- GtkType parent,
- const GtkEnumValue *values)
-{
- GtkType type_id;
- GtkTypeInfo info;
-
- info.type_name = name;
- info.object_size = 0;
- info.class_size = 0;
- info.class_init_func = NULL;
- info.object_init_func = NULL;
- info.reserved_1 = (gpointer) values;
- info.reserved_2 = NULL;
-
- /* relookup pointers afterwards.
- */
- type_id = gtk_type_create (parent, name, &info);
-
- if (type_id && values)
- {
- guint i;
-
- /* check for proper type consistency and NULL termination
- * of value array
- */
- g_assert (GTK_FUNDAMENTAL_TYPE (type_id) == GTK_TYPE_ENUM ||
- GTK_FUNDAMENTAL_TYPE (type_id) == GTK_TYPE_FLAGS);
-
- i = 0;
- while (values[i].value_name)
- i++;
-
- g_assert (values[i].value_name == NULL && values[i].value_nick == NULL);
- }
-
- return type_id;
-}
+ g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL);
+ g_return_val_if_fail (value_name != NULL, NULL);
-GtkType
-gtk_type_register_enum (const gchar *type_name,
- GtkEnumValue *values)
-{
- GtkType type_id;
- gchar *name;
-
- g_return_val_if_fail (type_name != NULL, 0);
-
- name = g_strdup (type_name);
-
- /* relookup pointers afterwards.
- */
- type_id = gtk_type_register_intern (name, GTK_TYPE_ENUM, values);
-
- if (!type_id)
- g_free (name);
-
- return type_id;
-}
+ class = gtk_type_class (enum_type);
+ value = g_enum_get_value_by_name (class, value_name);
+ if (!value)
+ value = g_enum_get_value_by_nick (class, value_name);
-GtkType
-gtk_type_register_flags (const gchar *type_name,
- GtkFlagValue *values)
-{
- GtkType type_id;
- gchar *name;
-
- g_return_val_if_fail (type_name != NULL, 0);
-
- name = g_strdup (type_name);
-
- /* relookup pointers afterwards.
- */
- type_id = gtk_type_register_intern (name, GTK_TYPE_FLAGS, values);
-
- if (!type_id)
- g_free (name);
-
- return type_id;
+ return value;
}
-GtkTypeQuery*
-gtk_type_query (GtkType type)
+GtkFlagValue*
+gtk_type_flags_find_value (GtkType flags_type,
+ const gchar *value_name)
{
- GtkTypeNode *node;
-
- LOOKUP_TYPE_NODE (node, type);
- if (node)
- {
- GtkTypeQuery *query;
-
- query = g_new0 (GtkTypeQuery, 1);
- query->type = type;
- query->type_name = node->type_info.type_name;
- query->object_size = node->type_info.object_size;
- query->class_size = node->type_info.class_size;
-
- return query;
- }
-
- return NULL;
-}
-
-extern void gtk_object_init_type (void);
+ GtkFlagValue *value;
+ GFlagsClass *class;
-#include "makeenums.h" /* include for various places
- * with enum definitions
- */
-#include "gtktypebuiltins_vars.c" /* type variable declarations
- */
-#include "gtktypebuiltins_evals.c" /* enum value definition arrays
- */
+ g_return_val_if_fail (G_TYPE_IS_FLAGS (flags_type), NULL);
+ g_return_val_if_fail (value_name != NULL, NULL);
-static void
-gtk_type_init_builtin_types (void)
-{
- /* GTK_TYPE_INVALID has typeid 0. The first type id returned by
- * gtk_type_unique is 1, which is GTK_TYPE_NONE. And so on.
- */
-
- static const struct {
- GtkType type_id;
- gchar *name;
- } fundamental_info[] = {
- { GTK_TYPE_NONE, "void" },
- { GTK_TYPE_CHAR, "gchar" },
- { GTK_TYPE_UCHAR, "guchar" },
- { GTK_TYPE_BOOL, "gboolean" },
- { GTK_TYPE_INT, "gint" },
- { GTK_TYPE_UINT, "guint" },
- { GTK_TYPE_LONG, "glong" },
- { GTK_TYPE_ULONG, "gulong" },
- { GTK_TYPE_FLOAT, "gfloat" },
- { GTK_TYPE_DOUBLE, "gdouble" },
- { GTK_TYPE_STRING, "GtkString" },
- { GTK_TYPE_ENUM, "GtkEnum" },
- { GTK_TYPE_FLAGS, "GtkFlags" },
- { GTK_TYPE_BOXED, "GtkBoxed" },
- { GTK_TYPE_POINTER, "gpointer" },
-
- { GTK_TYPE_SIGNAL, "GtkSignal" },
- { GTK_TYPE_ARGS, "GtkArgs" },
- { GTK_TYPE_CALLBACK, "GtkCallback" },
- { GTK_TYPE_C_CALLBACK, "GtkCCallback" },
- { GTK_TYPE_FOREIGN, "GtkForeign" },
- };
- static struct {
- gchar *type_name;
- GtkType *type_id;
- GtkType parent;
- const GtkEnumValue *values;
- } builtin_info[GTK_TYPE_NUM_BUILTINS + 1] = {
-#include "gtktypebuiltins_ids.c" /* type entries */
- { NULL }
- };
- guint i;
-
- for (i = 0; i < sizeof (fundamental_info) / sizeof (fundamental_info[0]); i++)
- {
- GtkType type_id;
-
- /* relookup pointers afterwards.
- */
- type_id = gtk_type_register_intern (fundamental_info[i].name, 0, NULL);
-
- g_assert (type_id == fundamental_info[i].type_id);
- }
-
- gtk_object_init_type ();
-
- for (i = 0; i < GTK_TYPE_NUM_BUILTINS; i++)
- {
- GtkType type_id;
-
- g_assert (builtin_info[i].type_name != NULL);
-
- /* relookup pointers afterwards.
- */
- type_id = gtk_type_register_intern (builtin_info[i].type_name,
- builtin_info[i].parent,
- builtin_info[i].values);
-
- g_assert (GTK_TYPE_SEQNO (type_id) > GTK_TYPE_FUNDAMENTAL_MAX);
-
- (*builtin_info[i].type_id) = type_id;
- }
-}
+ class = gtk_type_class (flags_type);
+ value = g_flags_get_value_by_name (class, value_name);
+ if (!value)
+ value = g_flags_get_value_by_nick (class, value_name);
-GtkType
-gtk_identifier_get_type (void)
-{
- static GtkType identifier_type = 0;
-
- if (!identifier_type)
- identifier_type = gtk_type_register_intern ("GtkIdentifier", GTK_TYPE_STRING, NULL);
-
- return identifier_type;
+ return value;
}
*/
/*
- * Modified by the GTK+ Team and others 1997-1999. See the AUTHORS
+ * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
#define __GTK_TYPE_UTILS_H__
-#include <glib.h>
+#include <glib-object.h>
#ifdef __cplusplus
/* Fundamental Types
+ * many of these are just aliases for GLib types to maintain
+ * compatibility
*/
-typedef enum
+typedef enum /*< skip >*/
{
- GTK_TYPE_INVALID,
- GTK_TYPE_NONE,
-
- /* flat types */
- GTK_TYPE_CHAR,
- GTK_TYPE_UCHAR,
- GTK_TYPE_BOOL,
- GTK_TYPE_INT,
- GTK_TYPE_UINT,
- GTK_TYPE_LONG,
- GTK_TYPE_ULONG,
- GTK_TYPE_FLOAT,
- GTK_TYPE_DOUBLE,
- GTK_TYPE_STRING,
- GTK_TYPE_ENUM,
- GTK_TYPE_FLAGS,
- GTK_TYPE_BOXED,
- GTK_TYPE_POINTER,
-
- /* structured types */
- GTK_TYPE_SIGNAL,
- GTK_TYPE_ARGS,
- GTK_TYPE_CALLBACK,
- GTK_TYPE_C_CALLBACK,
- GTK_TYPE_FOREIGN,
-
- /* base type node of the object system */
- GTK_TYPE_OBJECT
+ GTK_TYPE_INVALID = G_TYPE_INVALID,
+ GTK_TYPE_NONE = G_TYPE_NONE,
+ GTK_TYPE_ENUM = G_TYPE_ENUM,
+ GTK_TYPE_FLAGS = G_TYPE_FLAGS,
+
+ /* GtkArg types */
+ GTK_TYPE_CHAR = G_TYPE_GTK_CHAR,
+ GTK_TYPE_UCHAR = G_TYPE_GTK_UCHAR,
+ GTK_TYPE_BOOL = G_TYPE_GTK_BOOL,
+ GTK_TYPE_INT = G_TYPE_GTK_INT,
+ GTK_TYPE_UINT = G_TYPE_GTK_UINT,
+ GTK_TYPE_LONG = G_TYPE_GTK_LONG,
+ GTK_TYPE_ULONG = G_TYPE_GTK_ULONG,
+ GTK_TYPE_FLOAT = G_TYPE_GTK_FLOAT,
+ GTK_TYPE_DOUBLE = G_TYPE_GTK_DOUBLE,
+ GTK_TYPE_STRING = G_TYPE_GTK_STRING,
+ GTK_TYPE_BOXED = G_TYPE_GTK_BOXED,
+ GTK_TYPE_POINTER = G_TYPE_GTK_POINTER,
+ GTK_TYPE_SIGNAL = G_TYPE_GTK_SIGNAL
} GtkFundamentalType;
-/* bounds definitions for type sets, these are provided to distinct
- * between fundamental types with if() statements, and to build
- * up foreign fundamentals
- */
-#define GTK_TYPE_FLAT_FIRST GTK_TYPE_CHAR
-#define GTK_TYPE_FLAT_LAST GTK_TYPE_POINTER
-#define GTK_TYPE_STRUCTURED_FIRST GTK_TYPE_SIGNAL
-#define GTK_TYPE_STRUCTURED_LAST GTK_TYPE_FOREIGN
-#define GTK_TYPE_FUNDAMENTAL_LAST GTK_TYPE_OBJECT
-#define GTK_TYPE_FUNDAMENTAL_MAX (32)
+/* --- type macros --- */
+#define GTK_CLASS_NAME(class) (g_type_name (G_TYPE_FROM_CLASS (class)))
+#define GTK_CLASS_TYPE(class) (G_TYPE_FROM_CLASS (class))
+#define GTK_TYPE_IS_OBJECT(type) (g_type_is_a ((type), GTK_TYPE_OBJECT))
-/* retrive a structure offset */
-#ifdef offsetof
-#define GTK_STRUCT_OFFSET(struct, field) ((gint) offsetof (struct, field))
-#else /* !offsetof */
-#define GTK_STRUCT_OFFSET(struct, field) ((gint) ((gchar*) &((struct*) 0)->field))
-#endif /* !offsetof */
-
-/* The debugging versions of the casting macros make sure the cast is "ok"
- * before proceeding, but they are definately slower than their less
- * careful counterparts as they involve extra ``is a'' checks.
- */
-#ifdef GTK_NO_CHECK_CASTS
-# define GTK_CHECK_CAST(tobj, cast_type, cast) ((cast*) (tobj))
-# define GTK_CHECK_CLASS_CAST(tclass,cast_type,cast) ((cast*) (tclass))
-#else /* !GTK_NO_CHECK_CASTS */
-# define GTK_CHECK_CAST(tobj, cast_type, cast) \
- ((cast*) gtk_type_check_object_cast ((GtkTypeObject*) (tobj), (cast_type)))
-# define GTK_CHECK_CLASS_CAST(tclass,cast_type,cast) \
- ((cast*) gtk_type_check_class_cast ((GtkTypeClass*) (tclass), (cast_type)))
-#endif /* GTK_NO_CHECK_CASTS */
-#define GTK_CHECK_GET_CLASS(obj,type,klass) ((klass*) (((GtkTypeObject*) (obj))->klass))
-
-/* Determines whether `type_object' and `type_class' are a type of `otype'.
+/* outdated macros that really shouldn't e used anymore,
+ * use the GLib type system instead
*/
-#define GTK_CHECK_TYPE(type_object, otype) ( \
- ((GtkTypeObject*) (type_object)) != NULL && \
- GTK_CHECK_CLASS_TYPE (((GtkTypeObject*) (type_object))->klass, (otype)) \
-)
-#define GTK_CHECK_CLASS_TYPE(type_class, otype) ( \
- ((GtkTypeClass*) (type_class)) != NULL && \
- gtk_type_is_a (((GtkTypeClass*) (type_class))->type, (otype)) \
-)
-
-
-
-
-/* A GtkType holds a unique type id
- */
-typedef guint GtkType;
-
-typedef struct _GtkTypeObject GtkTypeObject;
-typedef struct _GtkTypeClass GtkTypeClass;
+#ifndef GTK_DISABLE_COMPAT_H
+#define GTK_TYPE_FUNDAMENTAL_LAST (G_TYPE_LAST_RESERVED_FUNDAMENTAL - 1)
+#define GTK_TYPE_FUNDAMENTAL_MAX (G_TYPE_FUNDAMENTAL_MAX)
+#endif /* GTK_DISABLE_COMPAT_H */
+
+/* glib macro wrappers (compatibility) */
+#define GTK_STRUCT_OFFSET G_STRUCT_OFFSET
+#define GTK_CHECK_CAST G_TYPE_CHECK_INSTANCE_CAST
+#define GTK_CHECK_CLASS_CAST G_TYPE_CHECK_CLASS_CAST
+#define GTK_CHECK_GET_CLASS G_TYPE_INSTANCE_GET_CLASS
+#define GTK_CHECK_TYPE G_TYPE_CHECK_INSTANCE_TYPE
+#define GTK_CHECK_CLASS_TYPE G_TYPE_CHECK_CLASS_TYPE
+#define GTK_FUNDAMENTAL_TYPE G_TYPE_FUNDAMENTAL
+
+/* glib type wrappers (compatibility) */
+typedef GType GtkType;
+typedef GTypeInstance GtkTypeObject;
+typedef GTypeClass GtkTypeClass;
+typedef GBaseInitFunc GtkClassInitFunc;
+typedef GInstanceInitFunc GtkObjectInitFunc;
/* Builtin Types
*/
#include <gtk/gtktypebuiltins.h>
-#define GTK_TYPE_IDENTIFIER (gtk_identifier_get_type ())
-GtkType gtk_identifier_get_type (void);
-/* Macros
- */
-#define GTK_TYPE_MAKE(parent_t, seqno) (((seqno) << 8) | GTK_FUNDAMENTAL_TYPE (parent_t))
-#define GTK_FUNDAMENTAL_TYPE(type) ((GtkFundamentalType) ((type) & 0xFF))
-#define GTK_TYPE_SEQNO(type) ((type) > 0xFF ? (type) >> 8 : (type))
-
-typedef struct _GtkArg GtkArg;
-typedef struct _GtkObject GtkObject; /* forward declaration of object type */
-typedef struct _GtkTypeInfo GtkTypeInfo;
-typedef struct _GtkTypeQuery GtkTypeQuery;
-typedef struct _GtkEnumValue GtkEnumValue;
-typedef struct _GtkEnumValue GtkFlagValue;
-
-
-#define GTK_SIGNAL_FUNC(f) ((GtkSignalFunc) f)
-
-typedef void (*GtkClassInitFunc) (gpointer klass);
-typedef void (*GtkObjectInitFunc) (gpointer object,
- gpointer klass);
-typedef void (*GtkSignalFunc) ();
-typedef gint (*GtkFunction) (gpointer data);
-typedef void (*GtkDestroyNotify) (gpointer data);
-typedef void (*GtkCallbackMarshal) (GtkObject *object,
- gpointer data,
- guint n_args,
- GtkArg *args);
-typedef void (*GtkSignalMarshaller) (GtkObject *object,
- GtkSignalFunc func,
- gpointer func_data,
- GtkArg *args);
-
-/* deprecated */
-typedef void (*GtkArgGetFunc) (GtkObject*, GtkArg*, guint);
-typedef void (*GtkArgSetFunc) (GtkObject*, GtkArg*, guint);
-
-
-/* A GtkTypeObject defines the minimum structure requirements
- * for type instances. Type instances returned from gtk_type_new ()
- * and initialized through a GtkObjectInitFunc need to directly inherit
- * from this structure or at least copy its fields one by one.
+/* --- typedefs --- */
+/* here we come with some necessary forward declarations for structures and
+ * provide some fundamental function signatures
*/
-struct _GtkTypeObject
-{
- /* A pointer to the objects class. This will actually point to
- * the derived objects class struct (which will be derived from
- * GtkTypeClass).
- */
- GtkTypeClass *klass;
-};
-
-
-/* A GtkTypeClass defines the minimum structure requirements for
- * a types class. Classes returned from gtk_type_class () and
- * initialized through a GtkClassInitFunc need to directly inherit
- * from this structure or at least copy its fields one by one.
- */
-struct _GtkTypeClass
-{
- /* The type identifier for the objects class. There is
- * one unique identifier per class.
- */
- GtkType type;
-};
-
-
+typedef struct _GtkArg GtkArg;
+typedef struct _GtkObject GtkObject; /* object forward declaration */
+typedef struct _GtkTypeInfo GtkTypeInfo;
+typedef gint (*GtkFunction) (gpointer data);
+typedef void (*GtkDestroyNotify) (gpointer data);
+typedef void (*GtkCallbackMarshal) (GtkObject *object,
+ gpointer data,
+ guint n_args,
+ GtkArg *args);
+typedef void (*GtkSignalFunc) ();
+typedef void (*GtkSignalMarshaller) (GtkObject *object,
+ GtkSignalFunc func,
+ gpointer func_data,
+ GtkArg *args);
+#define GTK_SIGNAL_FUNC(f) ((GtkSignalFunc) (f))
+
+
+/* GtkArg, used to hold differently typed values */
struct _GtkArg
{
GtkType type;
gfloat float_data;
gdouble double_data;
gchar *string_data;
- gpointer pointer_data;
GtkObject *object_data;
+ gpointer pointer_data;
/* structured values */
struct {
GtkSignalFunc f;
gpointer d;
} signal_data;
- struct {
- gint n_args;
- GtkArg *args;
- } args_data;
- struct {
- GtkCallbackMarshal marshal;
- gpointer data;
- GtkDestroyNotify notify;
- } callback_data;
- struct {
- GtkFunction func;
- gpointer func_data;
- } c_callback_data;
- struct {
- gpointer data;
- GtkDestroyNotify notify;
- } foreign_data;
} d;
};
* to allow the usage of these macros in combination with the
* adress operator, e.g. >K_VALUE_CHAR (*arg)
*/
-
-/* flat values */
#define GTK_VALUE_CHAR(a) ((a).d.char_data)
#define GTK_VALUE_UCHAR(a) ((a).d.uchar_data)
#define GTK_VALUE_BOOL(a) ((a).d.bool_data)
#define GTK_VALUE_ENUM(a) ((a).d.int_data)
#define GTK_VALUE_FLAGS(a) ((a).d.uint_data)
#define GTK_VALUE_BOXED(a) ((a).d.pointer_data)
-#define GTK_VALUE_POINTER(a) ((a).d.pointer_data)
#define GTK_VALUE_OBJECT(a) ((a).d.object_data)
-
-/* structured values */
+#define GTK_VALUE_POINTER(a) ((a).d.pointer_data)
#define GTK_VALUE_SIGNAL(a) ((a).d.signal_data)
-#define GTK_VALUE_ARGS(a) ((a).d.args_data)
-#define GTK_VALUE_CALLBACK(a) ((a).d.callback_data)
-#define GTK_VALUE_C_CALLBACK(a) ((a).d.c_callback_data)
-#define GTK_VALUE_FOREIGN(a) ((a).d.foreign_data)
/* return location macros, these all narow down to
* pointer types, because return values need to be
* passed by reference
*/
-
-/* flat values */
#define GTK_RETLOC_CHAR(a) ((gchar*) (a).d.pointer_data)
#define GTK_RETLOC_UCHAR(a) ((guchar*) (a).d.pointer_data)
#define GTK_RETLOC_BOOL(a) ((gboolean*) (a).d.pointer_data)
#define GTK_RETLOC_ENUM(a) ((gint*) (a).d.pointer_data)
#define GTK_RETLOC_FLAGS(a) ((guint*) (a).d.pointer_data)
#define GTK_RETLOC_BOXED(a) ((gpointer*) (a).d.pointer_data)
-#define GTK_RETLOC_POINTER(a) ((gpointer*) (a).d.pointer_data)
#define GTK_RETLOC_OBJECT(a) ((GtkObject**) (a).d.pointer_data)
+#define GTK_RETLOC_POINTER(a) ((gpointer*) (a).d.pointer_data)
+/* GTK_RETLOC_SIGNAL() - no such thing */
+/* type registration, it is recommended to use
+ * g_type_register_static() or
+ * g_type_register_dynamic() instead
+ */
struct _GtkTypeInfo
{
gchar *type_name;
gpointer reserved_2;
GtkClassInitFunc base_class_init_func;
};
+GtkType gtk_type_unique (GtkType parent_type,
+ const GtkTypeInfo *gtkinfo);
+gpointer gtk_type_class (GtkType type);
+gpointer gtk_type_new (GtkType type);
-struct _GtkTypeQuery
-{
- GtkType type;
- const gchar *type_name;
- guint object_size;
- guint class_size;
-};
-struct _GtkEnumValue
-{
- guint value;
- gchar *value_name;
- gchar *value_nick;
-};
+/* --- initialize the type system --- */
+void gtk_type_init (void);
+
+/* --- compatibility defines --- */
+#define gtk_type_name g_type_name
+#define gtk_type_from_name g_type_from_name
+#define gtk_type_parent g_type_parent
+#define gtk_type_is_a g_type_is_a
-void gtk_type_init (void);
-GtkType gtk_type_unique (GtkType parent_type,
- const GtkTypeInfo *type_info);
-void gtk_type_set_chunk_alloc (GtkType type,
- guint n_chunks);
-gchar* gtk_type_name (GtkType type);
-GtkType gtk_type_from_name (const gchar *name);
-GtkType gtk_type_parent (GtkType type);
-gpointer gtk_type_class (GtkType type);
-gpointer gtk_type_parent_class (GtkType type);
-GList* gtk_type_children_types (GtkType type);
-gpointer gtk_type_new (GtkType type);
-void gtk_type_free (GtkType type,
- gpointer mem);
-void gtk_type_describe_heritage (GtkType type);
-void gtk_type_describe_tree (GtkType type,
- gboolean show_size);
-gboolean gtk_type_is_a (GtkType type,
- GtkType is_a_type);
-GtkTypeObject* gtk_type_check_object_cast (GtkTypeObject *type_object,
- GtkType cast_type);
-GtkTypeClass* gtk_type_check_class_cast (GtkTypeClass *klass,
- GtkType cast_type);
-GtkType gtk_type_register_enum (const gchar *type_name,
- GtkEnumValue *values);
-GtkType gtk_type_register_flags (const gchar *type_name,
- GtkFlagValue *values);
+
+/* enum/flags compatibility functions, we strongly
+ * recommend to use the glib enum/flags classes directly
+ */
+typedef GEnumValue GtkEnumValue;
+typedef GFlagsValue GtkFlagValue;
GtkEnumValue* gtk_type_enum_get_values (GtkType enum_type);
GtkFlagValue* gtk_type_flags_get_values (GtkType flags_type);
GtkEnumValue* gtk_type_enum_find_value (GtkType enum_type,
const gchar *value_name);
-GtkFlagValue* gtk_type_flags_find_value (GtkType flag_type,
+GtkFlagValue* gtk_type_flags_find_value (GtkType flags_type,
const gchar *value_name);
-/* set the argument collector alias for foreign fundamentals */
-void gtk_type_set_varargs_type (GtkType foreign_type,
- GtkType varargs_type);
-GtkType gtk_type_get_varargs_type (GtkType foreign_type);
-/* Report internal information about a type. The caller has the
- * responsibility to invoke a subsequent g_free (returned_data); but
- * must not modify data pointed to by the members of GtkTypeQuery
- */
-GtkTypeQuery* gtk_type_query (GtkType type);
+/* urg */
+extern GType GTK_TYPE_IDENTIFIER;
#ifdef __cplusplus
static void gtk_viewport_class_init (GtkViewportClass *klass);
static void gtk_viewport_init (GtkViewport *viewport);
static void gtk_viewport_destroy (GtkObject *object);
-static void gtk_viewport_finalize (GtkObject *object);
static void gtk_viewport_set_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
container_class = (GtkContainerClass*) class;
parent_class = (GtkBinClass*) gtk_type_class (GTK_TYPE_BIN);
- gtk_object_add_arg_type ("GtkViewport::hadjustment",
- GTK_TYPE_ADJUSTMENT,
- GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
- ARG_HADJUSTMENT);
- gtk_object_add_arg_type ("GtkViewport::vadjustment",
- GTK_TYPE_ADJUSTMENT,
- GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
- ARG_VADJUSTMENT);
- gtk_object_add_arg_type ("GtkViewport::shadow_type",
- GTK_TYPE_SHADOW_TYPE,
- GTK_ARG_READWRITE,
- ARG_SHADOW_TYPE);
-
object_class->set_arg = gtk_viewport_set_arg;
object_class->get_arg = gtk_viewport_get_arg;
object_class->destroy = gtk_viewport_destroy;
- object_class->finalize = gtk_viewport_finalize;
widget_class->map = gtk_viewport_map;
widget_class->unmap = gtk_viewport_unmap;
widget_class->size_request = gtk_viewport_size_request;
widget_class->size_allocate = gtk_viewport_size_allocate;
widget_class->style_set = gtk_viewport_style_set;
+
+ container_class->add = gtk_viewport_add;
+
+ class->set_scroll_adjustments = gtk_viewport_set_scroll_adjustments;
+
+ gtk_object_add_arg_type ("GtkViewport::hadjustment",
+ GTK_TYPE_ADJUSTMENT,
+ GTK_ARG_READWRITE,
+ ARG_HADJUSTMENT);
+ gtk_object_add_arg_type ("GtkViewport::vadjustment",
+ GTK_TYPE_ADJUSTMENT,
+ GTK_ARG_READWRITE,
+ ARG_VADJUSTMENT);
+ gtk_object_add_arg_type ("GtkViewport::shadow_type",
+ GTK_TYPE_SHADOW_TYPE,
+ GTK_ARG_READWRITE,
+ ARG_SHADOW_TYPE);
widget_class->set_scroll_adjustments_signal =
gtk_signal_new ("set_scroll_adjustments",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkViewportClass, set_scroll_adjustments),
gtk_marshal_NONE__POINTER_POINTER,
GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
-
- container_class->add = gtk_viewport_add;
-
- class->set_scroll_adjustments = gtk_viewport_set_scroll_adjustments;
}
static void
GtkViewport *viewport = GTK_VIEWPORT (object);
if (viewport->hadjustment)
- gtk_signal_disconnect_by_data (GTK_OBJECT (viewport->hadjustment),
- viewport);
+ {
+ gtk_signal_disconnect_by_data (GTK_OBJECT (viewport->hadjustment), viewport);
+ gtk_object_unref (GTK_OBJECT (viewport->hadjustment));
+ viewport->hadjustment = NULL;
+ }
if (viewport->vadjustment)
- gtk_signal_disconnect_by_data (GTK_OBJECT (viewport->vadjustment),
- viewport);
-
- GTK_OBJECT_CLASS(parent_class)->destroy (object);
-}
-
-static void
-gtk_viewport_finalize (GtkObject *object)
-{
- GtkViewport *viewport = GTK_VIEWPORT (object);
-
- gtk_object_unref (GTK_OBJECT (viewport->hadjustment));
- gtk_object_unref (GTK_OBJECT (viewport->vadjustment));
+ {
+ gtk_signal_disconnect_by_data (GTK_OBJECT (viewport->vadjustment), viewport);
+ gtk_object_unref (GTK_OBJECT (viewport->vadjustment));
+ viewport->vadjustment = NULL;
+ }
- GTK_OBJECT_CLASS(parent_class)->finalize (object);
+ GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
GtkAdjustment*
g_return_val_if_fail (viewport != NULL, NULL);
g_return_val_if_fail (GTK_IS_VIEWPORT (viewport), NULL);
+ if (!viewport->hadjustment)
+ gtk_viewport_set_hadjustment (viewport, NULL);
+
return viewport->hadjustment;
}
g_return_val_if_fail (viewport != NULL, NULL);
g_return_val_if_fail (GTK_IS_VIEWPORT (viewport), NULL);
+ if (!viewport->vadjustment)
+ gtk_viewport_set_vadjustment (viewport, NULL);
+
return viewport->vadjustment;
}
if (viewport->hadjustment && viewport->hadjustment != adjustment)
{
- gtk_signal_disconnect_by_data (GTK_OBJECT (viewport->hadjustment),
- (gpointer) viewport);
+ gtk_signal_disconnect_by_data (GTK_OBJECT (viewport->hadjustment), viewport);
gtk_object_unref (GTK_OBJECT (viewport->hadjustment));
+ viewport->hadjustment = NULL;
}
if (!adjustment)
if (viewport->vadjustment && viewport->vadjustment != adjustment)
{
- gtk_signal_disconnect_by_data (GTK_OBJECT (viewport->vadjustment),
- (gpointer) viewport);
+ gtk_signal_disconnect_by_data (GTK_OBJECT (viewport->vadjustment), viewport);
gtk_object_unref (GTK_OBJECT (viewport->vadjustment));
+ viewport->vadjustment = NULL;
}
if (!adjustment)
viewport = GTK_VIEWPORT (widget);
bin = GTK_BIN (widget);
+ /* demand creation */
+ if (!viewport->hadjustment)
+ gtk_viewport_set_hadjustment (viewport, NULL);
+ if (!viewport->vadjustment)
+ gtk_viewport_set_hadjustment (viewport, NULL);
+
border_width = GTK_CONTAINER (widget)->border_width;
child_allocation.x = 0;
#include "gdk/gdkkeysyms.h"
-#define SCALE_CLASS(w) GTK_SCALE_CLASS (GTK_OBJECT (w)->klass)
-#define RANGE_CLASS(w) GTK_RANGE_CLASS (GTK_OBJECT (w)->klass)
+#define SCALE_CLASS(w) GTK_SCALE_GET_CLASS (w)
+#define RANGE_CLASS(w) GTK_RANGE_GET_CLASS (w)
enum {
ARG_0,
gtk_object_add_arg_type ("GtkVScale::adjustment",
GTK_TYPE_ADJUSTMENT,
- GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+ GTK_ARG_READWRITE,
ARG_ADJUSTMENT);
object_class->set_arg = gtk_vscale_set_arg;
#define EPSILON 0.01
-#define RANGE_CLASS(w) GTK_RANGE_CLASS (GTK_OBJECT (w)->klass)
+#define RANGE_CLASS(w) GTK_RANGE_GET_CLASS (w)
enum {
ARG_0,
gtk_object_add_arg_type ("GtkVScrollbar::adjustment",
GTK_TYPE_ADJUSTMENT,
- GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+ GTK_ARG_READWRITE,
ARG_ADJUSTMENT);
object_class->set_arg = gtk_vscrollbar_set_arg;
#include "gdk/gdkprivate.h" /* Used in gtk_reset_shapes_recurse to avoid copy */
-#define WIDGET_CLASS(w) GTK_WIDGET_CLASS (GTK_OBJECT (w)->klass)
+#define WIDGET_CLASS(w) GTK_WIDGET_GET_CLASS (w)
#define INIT_PATH_SIZE (512)
static void gtk_widget_get_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
-static void gtk_widget_shutdown (GtkObject *object);
+static void gtk_widget_shutdown (GObject *object);
static void gtk_widget_real_destroy (GtkObject *object);
-static void gtk_widget_finalize (GtkObject *object);
+static void gtk_widget_finalize (GObject *object);
static void gtk_widget_real_show (GtkWidget *widget);
static void gtk_widget_real_hide (GtkWidget *widget);
static void gtk_widget_real_map (GtkWidget *widget);
static GtkWidgetAuxInfo* gtk_widget_aux_info_new (void);
static void gtk_widget_aux_info_destroy (GtkWidgetAuxInfo *aux_info);
-static GtkObjectClass *parent_class = NULL;
+static gpointer parent_class = NULL;
static guint widget_signals[LAST_SIGNAL] = { 0 };
static GMemChunk *aux_info_mem_chunk = NULL;
(GtkClassInitFunc) NULL,
};
- widget_type = gtk_type_unique (gtk_object_get_type (), &widget_info);
+ widget_type = gtk_type_unique (GTK_TYPE_OBJECT, &widget_info);
}
return widget_type;
static void
gtk_widget_class_init (GtkWidgetClass *klass)
{
- GtkObjectClass *object_class;
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+ GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
- object_class = (GtkObjectClass*) klass;
+ parent_class = gtk_type_class (GTK_TYPE_OBJECT);
+
+ gobject_class->shutdown = gtk_widget_shutdown;
+ gobject_class->finalize = gtk_widget_finalize;
+
+ object_class->set_arg = gtk_widget_set_arg;
+ object_class->get_arg = gtk_widget_get_arg;
+ object_class->destroy = gtk_widget_real_destroy;
- parent_class = gtk_type_class (gtk_object_get_type ());
+ klass->activate_signal = 0;
+ klass->set_scroll_adjustments_signal = 0;
+ klass->show = gtk_widget_real_show;
+ klass->show_all = gtk_widget_show;
+ klass->hide = gtk_widget_real_hide;
+ klass->hide_all = gtk_widget_hide;
+ klass->map = gtk_widget_real_map;
+ klass->unmap = gtk_widget_real_unmap;
+ klass->realize = gtk_widget_real_realize;
+ klass->unrealize = gtk_widget_real_unrealize;
+ klass->draw = gtk_widget_real_draw;
+ klass->draw_focus = NULL;
+ klass->size_request = gtk_widget_real_size_request;
+ klass->size_allocate = gtk_widget_real_size_allocate;
+ klass->state_changed = NULL;
+ klass->parent_set = NULL;
+ klass->style_set = gtk_widget_style_set;
+ klass->add_accelerator = (void*) gtk_accel_group_handle_add;
+ klass->remove_accelerator = (void*) gtk_accel_group_handle_remove;
+ klass->grab_focus = gtk_widget_real_grab_focus;
+ klass->event = NULL;
+ klass->button_press_event = NULL;
+ klass->button_release_event = NULL;
+ klass->motion_notify_event = NULL;
+ klass->delete_event = NULL;
+ klass->destroy_event = NULL;
+ klass->expose_event = NULL;
+ klass->key_press_event = gtk_widget_real_key_press_event;
+ klass->key_release_event = gtk_widget_real_key_release_event;
+ klass->enter_notify_event = NULL;
+ klass->leave_notify_event = NULL;
+ klass->configure_event = NULL;
+ klass->focus_in_event = NULL;
+ klass->focus_out_event = NULL;
+ klass->map_event = NULL;
+ klass->unmap_event = NULL;
+ klass->property_notify_event = gtk_selection_property_notify;
+ klass->selection_clear_event = gtk_selection_clear;
+ klass->selection_request_event = gtk_selection_request;
+ klass->selection_notify_event = gtk_selection_notify;
+ klass->selection_received = NULL;
+ klass->proximity_in_event = NULL;
+ klass->proximity_out_event = NULL;
+ klass->drag_begin = NULL;
+ klass->drag_end = NULL;
+ klass->drag_data_delete = NULL;
+ klass->drag_leave = NULL;
+ klass->drag_motion = NULL;
+ klass->drag_drop = NULL;
+ klass->drag_data_received = NULL;
+
+ klass->no_expose_event = NULL;
+
+ klass->debug_msg = gtk_widget_debug_msg;
gtk_object_add_arg_type ("GtkWidget::name", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_NAME);
gtk_object_add_arg_type ("GtkWidget::parent", GTK_TYPE_CONTAINER, GTK_ARG_READWRITE, ARG_PARENT);
widget_signals[SHOW] =
gtk_signal_new ("show",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, show),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
widget_signals[HIDE] =
gtk_signal_new ("hide",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, hide),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
widget_signals[MAP] =
gtk_signal_new ("map",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, map),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
widget_signals[UNMAP] =
gtk_signal_new ("unmap",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, unmap),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
widget_signals[REALIZE] =
gtk_signal_new ("realize",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, realize),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
widget_signals[UNREALIZE] =
gtk_signal_new ("unrealize",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, unrealize),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
widget_signals[DRAW] =
gtk_signal_new ("draw",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, draw),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1,
widget_signals[DRAW_FOCUS] =
gtk_signal_new ("draw_focus",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, draw_focus),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
widget_signals[DRAW_DEFAULT] =
gtk_signal_new ("draw_default",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, draw_default),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
widget_signals[SIZE_REQUEST] =
gtk_signal_new ("size_request",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, size_request),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1,
widget_signals[SIZE_ALLOCATE] =
gtk_signal_new ("size_allocate",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, size_allocate),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1,
widget_signals[STATE_CHANGED] =
gtk_signal_new ("state_changed",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, state_changed),
gtk_marshal_NONE__UINT,
GTK_TYPE_NONE, 1,
widget_signals[PARENT_SET] =
gtk_signal_new ("parent_set",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, parent_set),
gtk_marshal_NONE__OBJECT,
GTK_TYPE_NONE, 1,
widget_signals[STYLE_SET] =
gtk_signal_new ("style_set",
GTK_RUN_FIRST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, style_set),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1,
GTK_TYPE_STYLE);
widget_signals[ADD_ACCELERATOR] =
- gtk_accel_group_create_add (object_class->type, GTK_RUN_LAST,
+ gtk_accel_group_create_add (GTK_CLASS_TYPE (object_class), GTK_RUN_LAST,
GTK_SIGNAL_OFFSET (GtkWidgetClass, add_accelerator));
widget_signals[REMOVE_ACCELERATOR] =
- gtk_accel_group_create_remove (object_class->type, GTK_RUN_LAST,
+ gtk_accel_group_create_remove (GTK_CLASS_TYPE (object_class), GTK_RUN_LAST,
GTK_SIGNAL_OFFSET (GtkWidgetClass, remove_accelerator));
widget_signals[GRAB_FOCUS] =
gtk_signal_new ("grab_focus",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, grab_focus),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
widget_signals[EVENT] =
gtk_signal_new ("event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[BUTTON_PRESS_EVENT] =
gtk_signal_new ("button_press_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, button_press_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[BUTTON_RELEASE_EVENT] =
gtk_signal_new ("button_release_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, button_release_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[SCROLL_EVENT] =
gtk_signal_new ("scroll_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, scroll_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[MOTION_NOTIFY_EVENT] =
gtk_signal_new ("motion_notify_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, motion_notify_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[DELETE_EVENT] =
gtk_signal_new ("delete_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, delete_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[DESTROY_EVENT] =
gtk_signal_new ("destroy_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, destroy_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[EXPOSE_EVENT] =
gtk_signal_new ("expose_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, expose_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[KEY_PRESS_EVENT] =
gtk_signal_new ("key_press_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, key_press_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[KEY_RELEASE_EVENT] =
gtk_signal_new ("key_release_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, key_release_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[ENTER_NOTIFY_EVENT] =
gtk_signal_new ("enter_notify_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, enter_notify_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[LEAVE_NOTIFY_EVENT] =
gtk_signal_new ("leave_notify_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, leave_notify_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[CONFIGURE_EVENT] =
gtk_signal_new ("configure_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, configure_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[FOCUS_IN_EVENT] =
gtk_signal_new ("focus_in_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, focus_in_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[FOCUS_OUT_EVENT] =
gtk_signal_new ("focus_out_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, focus_out_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[MAP_EVENT] =
gtk_signal_new ("map_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, map_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[UNMAP_EVENT] =
gtk_signal_new ("unmap_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, unmap_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[PROPERTY_NOTIFY_EVENT] =
gtk_signal_new ("property_notify_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, property_notify_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[SELECTION_CLEAR_EVENT] =
gtk_signal_new ("selection_clear_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_clear_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[SELECTION_REQUEST_EVENT] =
gtk_signal_new ("selection_request_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_request_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[SELECTION_NOTIFY_EVENT] =
gtk_signal_new ("selection_notify_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_notify_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[SELECTION_RECEIVED] =
gtk_signal_new ("selection_received",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_received),
gtk_marshal_NONE__POINTER_UINT,
GTK_TYPE_NONE, 2,
widget_signals[SELECTION_GET] =
gtk_signal_new ("selection_get",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_get),
gtk_marshal_NONE__POINTER_UINT_UINT,
GTK_TYPE_NONE, 3,
widget_signals[PROXIMITY_IN_EVENT] =
gtk_signal_new ("proximity_in_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, proximity_in_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[PROXIMITY_OUT_EVENT] =
gtk_signal_new ("proximity_out_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, proximity_out_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[DRAG_LEAVE] =
gtk_signal_new ("drag_leave",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_leave),
gtk_marshal_NONE__POINTER_UINT,
GTK_TYPE_NONE, 2,
widget_signals[DRAG_BEGIN] =
gtk_signal_new ("drag_begin",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_begin),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1,
widget_signals[DRAG_END] =
gtk_signal_new ("drag_end",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_end),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1,
widget_signals[DRAG_DATA_DELETE] =
gtk_signal_new ("drag_data_delete",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_data_delete),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1,
widget_signals[DRAG_MOTION] =
gtk_signal_new ("drag_motion",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_motion),
gtk_marshal_BOOL__POINTER_INT_INT_UINT,
GTK_TYPE_BOOL, 4,
widget_signals[DRAG_DROP] =
gtk_signal_new ("drag_drop",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_drop),
gtk_marshal_BOOL__POINTER_INT_INT_UINT,
GTK_TYPE_BOOL, 4,
widget_signals[DRAG_DATA_GET] =
gtk_signal_new ("drag_data_get",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_data_get),
gtk_marshal_NONE__POINTER_POINTER_UINT_UINT,
GTK_TYPE_NONE, 4,
widget_signals[DRAG_DATA_RECEIVED] =
gtk_signal_new ("drag_data_received",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_data_received),
gtk_marshal_NONE__POINTER_INT_INT_POINTER_UINT_UINT,
GTK_TYPE_NONE, 6,
widget_signals[VISIBILITY_NOTIFY_EVENT] =
gtk_signal_new ("visibility_notify_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, visibility_notify_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[CLIENT_EVENT] =
gtk_signal_new ("client_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, client_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[NO_EXPOSE_EVENT] =
gtk_signal_new ("no_expose_event",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, no_expose_event),
gtk_marshal_BOOL__POINTER,
GTK_TYPE_BOOL, 1,
widget_signals[DEBUG_MSG] =
gtk_signal_new ("debug_msg",
GTK_RUN_LAST | GTK_RUN_ACTION,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWidgetClass, debug_msg),
gtk_marshal_NONE__STRING,
GTK_TYPE_NONE, 1,
GTK_TYPE_STRING);
gtk_object_class_add_signals (object_class, widget_signals, LAST_SIGNAL);
-
- object_class->set_arg = gtk_widget_set_arg;
- object_class->get_arg = gtk_widget_get_arg;
- object_class->shutdown = gtk_widget_shutdown;
- object_class->destroy = gtk_widget_real_destroy;
- object_class->finalize = gtk_widget_finalize;
-
- klass->activate_signal = 0;
- klass->set_scroll_adjustments_signal = 0;
- klass->show = gtk_widget_real_show;
- klass->show_all = gtk_widget_show;
- klass->hide = gtk_widget_real_hide;
- klass->hide_all = gtk_widget_hide;
- klass->map = gtk_widget_real_map;
- klass->unmap = gtk_widget_real_unmap;
- klass->realize = gtk_widget_real_realize;
- klass->unrealize = gtk_widget_real_unrealize;
- klass->draw = gtk_widget_real_draw;
- klass->draw_focus = NULL;
- klass->size_request = gtk_widget_real_size_request;
- klass->size_allocate = gtk_widget_real_size_allocate;
- klass->state_changed = NULL;
- klass->parent_set = NULL;
- klass->style_set = gtk_widget_style_set;
- klass->add_accelerator = (void*) gtk_accel_group_handle_add;
- klass->remove_accelerator = (void*) gtk_accel_group_handle_remove;
- klass->grab_focus = gtk_widget_real_grab_focus;
- klass->event = NULL;
- klass->button_press_event = NULL;
- klass->button_release_event = NULL;
- klass->motion_notify_event = NULL;
- klass->delete_event = NULL;
- klass->destroy_event = NULL;
- klass->expose_event = NULL;
- klass->key_press_event = gtk_widget_real_key_press_event;
- klass->key_release_event = gtk_widget_real_key_release_event;
- klass->enter_notify_event = NULL;
- klass->leave_notify_event = NULL;
- klass->configure_event = NULL;
- klass->focus_in_event = NULL;
- klass->focus_out_event = NULL;
- klass->map_event = NULL;
- klass->unmap_event = NULL;
- klass->property_notify_event = gtk_selection_property_notify;
- klass->selection_clear_event = gtk_selection_clear;
- klass->selection_request_event = gtk_selection_request;
- klass->selection_notify_event = gtk_selection_notify;
- klass->selection_received = NULL;
- klass->proximity_in_event = NULL;
- klass->proximity_out_event = NULL;
- klass->drag_begin = NULL;
- klass->drag_end = NULL;
- klass->drag_data_delete = NULL;
- klass->drag_leave = NULL;
- klass->drag_motion = NULL;
- klass->drag_drop = NULL;
- klass->drag_data_received = NULL;
-
- klass->no_expose_event = NULL;
-
- klass->debug_msg = gtk_widget_debug_msg;
}
static void
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
- class = GTK_WIDGET_CLASS (GTK_OBJECT (widget)->klass);
+ class = GTK_WIDGET_GET_CLASS (widget);
if (class->show_all)
class->show_all (widget);
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
- class = GTK_WIDGET_CLASS (GTK_OBJECT (widget)->klass);
+ class = GTK_WIDGET_GET_CLASS (widget);
if (class->hide_all)
class->hide_all (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (GTK_WIDGET_CAN_DEFAULT (widget));
- window_type = gtk_window_get_type ();
+ window_type = GTK_TYPE_WINDOW;
window = widget->parent;
while (window && !gtk_type_is_a (GTK_WIDGET_TYPE (window), window_type))
}
static void
-gtk_widget_shutdown (GtkObject *object)
+gtk_widget_shutdown (GObject *object)
{
- GtkWidget *widget;
-
- /* gtk_object_destroy() will already hold a refcount on object
- */
- widget = GTK_WIDGET (object);
+ GtkWidget *widget = GTK_WIDGET (object);
if (widget->parent)
gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
if (GTK_WIDGET_REALIZED (widget))
gtk_widget_unrealize (widget);
- parent_class->shutdown (object);
+ G_OBJECT_CLASS (parent_class)->shutdown (object);
}
static void
}
gtk_style_unref (widget->style);
- widget->style = NULL;
+ widget->style = gtk_widget_peek_style ();
+ gtk_style_ref (widget->style);
- parent_class->destroy (object);
+ GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
static void
-gtk_widget_finalize (GtkObject *object)
+gtk_widget_finalize (GObject *object)
{
- GtkWidget *widget;
+ GtkWidget *widget = GTK_WIDGET (object);
GtkWidgetAuxInfo *aux_info;
gint *events;
GdkExtensionMode *mode;
+ GtkStyle *saved_style;
- widget = GTK_WIDGET (object);
-
+ gtk_grab_remove (widget);
+ gtk_selection_remove_all (widget);
+
+ saved_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id);
+ if (saved_style)
+ {
+ gtk_style_unref (saved_style);
+ gtk_object_remove_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id);
+ }
+
+ gtk_style_unref (widget->style);
+ widget->style = NULL;
+
if (widget->name)
g_free (widget->name);
if (mode)
g_free (mode);
- parent_class->finalize (object);
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
/*****************************************
{
GtkWidget *window;
- window = gtk_widget_get_ancestor (widget, gtk_window_get_type ());
+ window = gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW);
if (window)
gtk_window_set_focus (GTK_WINDOW (window), NULL);
}
gtk_reset_shapes_recurse (widget, widget->window);
}
-void
+GtkWidget*
gtk_widget_ref (GtkWidget *widget)
{
- g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
- gtk_object_ref ((GtkObject*) widget);
+ return (GtkWidget*) g_object_ref ((GObject*) widget);
}
void
gtk_widget_unref (GtkWidget *widget)
{
- g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
- gtk_object_unref ((GtkObject*) widget);
+ g_object_unref ((GObject*) widget);
}
void
GtkWidget* gtk_widget_newv (GtkType type,
guint nargs,
GtkArg *args);
-void gtk_widget_ref (GtkWidget *widget);
+GtkWidget* gtk_widget_ref (GtkWidget *widget);
void gtk_widget_unref (GtkWidget *widget);
void gtk_widget_destroy (GtkWidget *widget);
void gtk_widget_destroyed (GtkWidget *widget,
static void gtk_window_get_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
-static void gtk_window_shutdown (GtkObject *object);
+static void gtk_window_shutdown (GObject *object);
static void gtk_window_destroy (GtkObject *object);
-static void gtk_window_finalize (GtkObject *object);
+static void gtk_window_finalize (GObject *object);
static void gtk_window_show (GtkWidget *widget);
static void gtk_window_hide (GtkWidget *widget);
static void gtk_window_map (GtkWidget *widget);
gboolean create);
static void gtk_window_geometry_destroy (GtkWindowGeometryInfo *info);
+static GSList *toplevel_list = NULL;
static GtkBinClass *parent_class = NULL;
-static guint window_signals[LAST_SIGNAL] = { 0 };
+static guint window_signals[LAST_SIGNAL] = { 0 };
GtkType
static void
gtk_window_class_init (GtkWindowClass *klass)
{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkContainerClass *container_class;
parent_class = gtk_type_class (gtk_bin_get_type ());
+ gobject_class->shutdown = gtk_window_shutdown;
+ gobject_class->finalize = gtk_window_finalize;
+
gtk_object_add_arg_type ("GtkWindow::type", GTK_TYPE_WINDOW_TYPE, GTK_ARG_READWRITE, ARG_TYPE);
gtk_object_add_arg_type ("GtkWindow::title", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_TITLE);
gtk_object_add_arg_type ("GtkWindow::auto_shrink", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_AUTO_SHRINK);
window_signals[SET_FOCUS] =
gtk_signal_new ("set_focus",
GTK_RUN_LAST,
- object_class->type,
+ GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkWindowClass, set_focus),
gtk_marshal_NONE__POINTER,
GTK_TYPE_NONE, 1,
object_class->set_arg = gtk_window_set_arg;
object_class->get_arg = gtk_window_get_arg;
- object_class->shutdown = gtk_window_shutdown;
object_class->destroy = gtk_window_destroy;
- object_class->finalize = gtk_window_finalize;
widget_class->show = gtk_window_show;
widget_class->hide = gtk_window_hide;
window->position = GTK_WIN_POS_NONE;
window->use_uposition = TRUE;
window->modal = FALSE;
-
- gtk_container_register_toplevel (GTK_CONTAINER (window));
+
+ gtk_widget_ref (GTK_WIDGET (window));
+ gtk_object_sink (GTK_OBJECT (window));
+ window->has_user_ref_count = TRUE;
+ toplevel_list = g_slist_prepend (toplevel_list, window);
}
static void
gtk_grab_remove (GTK_WIDGET (window));
}
+GList*
+gtk_window_list_toplevels (void)
+{
+ GList *list = NULL;
+ GSList *slist;
+
+ for (slist = toplevel_list; slist; slist = slist->next)
+ list = g_list_prepend (list, gtk_widget_ref (slist->data));
+
+ return list;
+}
+
void
gtk_window_add_embedded_xid (GtkWindow *window, guint xid)
{
}
static void
-gtk_window_shutdown (GtkObject *object)
+gtk_window_shutdown (GObject *object)
{
GtkWindow *window;
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_WINDOW (object));
window = GTK_WINDOW (object);
gtk_window_set_focus (window, NULL);
gtk_window_set_default (window, NULL);
- GTK_OBJECT_CLASS (parent_class)->shutdown (object);
+ G_OBJECT_CLASS (parent_class)->shutdown (object);
}
static void
{
GtkWindow *window;
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_WINDOW (object));
window = GTK_WINDOW (object);
-
- gtk_container_unregister_toplevel (GTK_CONTAINER (object));
if (window->transient_parent)
gtk_window_unset_transient_for (window);
+ if (window->has_user_ref_count)
+ {
+ window->has_user_ref_count = FALSE;
+ gtk_widget_unref (GTK_WIDGET (window));
+ }
+
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
static void
-gtk_window_finalize (GtkObject *object)
+gtk_window_finalize (GObject *object)
{
GtkWindow *window;
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_WINDOW (object));
window = GTK_WINDOW (object);
+
+ toplevel_list = g_slist_remove (toplevel_list, window);
+
g_free (window->title);
g_free (window->wmclass_name);
g_free (window->wmclass_class);
- GTK_OBJECT_CLASS(parent_class)->finalize (object);
+ G_OBJECT_CLASS(parent_class)->finalize (object);
}
static void
* then, the RC file will up to date, so we have to tell
* them now.
*/
- GList *toplevels;
-
- toplevels = gtk_container_get_toplevels();
- while (toplevels)
+ GList *list, *toplevels = gtk_window_list_toplevels ();
+
+ for (list = toplevels; list; list = list->next)
{
- gtk_widget_reset_rc_styles (toplevels->data);
- toplevels = toplevels->next;
+ gtk_widget_reset_rc_styles (list->data);
+ gtk_widget_unref (list->data);
}
+ g_list_free (toplevels);
}
}
GtkWindow *transient_parent;
gushort resize_count;
+ guint has_user_ref_count : 1;
guint allow_shrink : 1;
guint allow_grow : 1;
guint auto_shrink : 1;
/* If window is set modal, input will be grabbed when show and released when hide */
void gtk_window_set_modal (GtkWindow *window,
gboolean modal);
+GList* gtk_window_list_toplevels (void);
+
/* --- internal functions --- */
void gtk_window_set_focus (GtkWindow *window,
END {
if (gen_macros)
- printf("\n#define\tGTK_TYPE_NUM_BUILTINS\t(%u)\n", type_counter);
+ printf("\n#define\tGTK_TYPE_N_BUILTINS\t(%u)\n", type_counter);
}
}
source_widget = gtk_drag_get_source_widget (context);
- g_print("motion, source %s\n", source_widget ?
- gtk_type_name (GTK_OBJECT (source_widget)->klass->type) :
- "unknown");
+ g_print ("motion, source %s\n", source_widget ?
+ GTK_OBJECT_TYPE_NAME (source_widget) :
+ "NULL");
gdk_drag_status (context, context->suggested_action, time);
return TRUE;
guint c;
GdkCursor *cursor;
GtkWidget *label;
- GtkFlagValue *vals;
+ GtkEnumValue *vals;
c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
c &= 0xfe;
gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
- gtk_signal_connect_object (
- GTK_OBJECT (window),
- "motion_notify_event",
- GTK_SIGNAL_FUNC(
- GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
- GTK_OBJECT (ruler));
-
+ gtk_signal_connect_object (GTK_OBJECT (window),
+ "motion_notify_event",
+ GTK_SIGNAL_FUNC (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
+ GTK_OBJECT (ruler));
+
gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ruler);
ruler = gtk_vruler_new ();
gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
- gtk_signal_connect_object (
- GTK_OBJECT (window),
- "motion_notify_event",
- GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
- GTK_OBJECT (ruler));
-
+ gtk_signal_connect_object (GTK_OBJECT (window),
+ "motion_notify_event",
+ GTK_SIGNAL_FUNC (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
+ GTK_OBJECT (ruler));
+
gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (ruler);
}
source_widget = gtk_drag_get_source_widget (context);
- g_print("motion, source %s\n", source_widget ?
- gtk_type_name (GTK_OBJECT (source_widget)->klass->type) :
- "unknown");
+ g_print ("motion, source %s\n", source_widget ?
+ GTK_OBJECT_TYPE_NAME (source_widget) :
+ "NULL");
gdk_drag_status (context, context->suggested_action, time);
return TRUE;
guint c;
GdkCursor *cursor;
GtkWidget *label;
- GtkFlagValue *vals;
+ GtkEnumValue *vals;
c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
c &= 0xfe;
gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
- gtk_signal_connect_object (
- GTK_OBJECT (window),
- "motion_notify_event",
- GTK_SIGNAL_FUNC(
- GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
- GTK_OBJECT (ruler));
-
+ gtk_signal_connect_object (GTK_OBJECT (window),
+ "motion_notify_event",
+ GTK_SIGNAL_FUNC (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
+ GTK_OBJECT (ruler));
+
gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ruler);
ruler = gtk_vruler_new ();
gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
- gtk_signal_connect_object (
- GTK_OBJECT (window),
- "motion_notify_event",
- GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
- GTK_OBJECT (ruler));
-
+ gtk_signal_connect_object (GTK_OBJECT (window),
+ "motion_notify_event",
+ GTK_SIGNAL_FUNC (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
+ GTK_OBJECT (ruler));
+
gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (ruler);
projects / gtk4.git / commitdiff